all.hpp

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 2018-2019 Blue Brain Project
 *
 * This file is part of NMODL distributed under the terms of the GNU
 * Lesser General Public License. See top-level LICENSE file for details.
 *************************************************************************/

///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///

#pragma once

/**
 * \dir
 * \brief Auto generated AST Implementations
 *
 * \file
 * \brief Auto generated AST classes declaration
 */

#include "ast/ast.hpp"

#ifndef NMODL_AST_NODE_HPP
#define NMODL_AST_NODE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all AST node
 *
 * Base class for all nodes in the AST. This can replace ast::Ast in
  * the next refactoring.
  * 
*/
class Node : public Ast {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Node() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Node
   * \return true as object is of type ast::Node
   */
  bool is_node () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Node* clone() const override {
    return new Node(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NODE
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NODE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Node"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Node";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Node>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Node>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NODE_HPP
#ifndef NMODL_AST_STATEMENT_HPP
#define NMODL_AST_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Statement : public Node {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Statement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Statement
   * \return true as object is of type ast::Statement
   */
  bool is_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Statement* clone() const override {
    return new Statement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Statement"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Statement";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Statement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Statement>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STATEMENT_HPP
#ifndef NMODL_AST_EXPRESSION_HPP
#define NMODL_AST_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all expressions in the NMODL
 *
 * Base class for all expression types. This is one of the top level node
  * in the AST representing higher level expression constructs. %Expressions
  * can be a variable itself or complex binary expressions.
  * 
  * \sa ast::Statement
  * 
*/
class Expression : public Node {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Expression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Expression
   * \return true as object is of type ast::Expression
   */
  bool is_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Expression* clone() const override {
    return new Expression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Expression"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Expression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Expression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Expression>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EXPRESSION_HPP
#ifndef NMODL_AST_BLOCK_HPP
#define NMODL_AST_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all block scoped nodes
 *
 * NMODL has different local and global block scoped nodes like
  * ast::NeuronBlock, ast::ParamBlock, ast::IfStatement etc. Ast::Block
  * is base class and defines common interface for these nodes.
  * 
*/
class Block : public Expression {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Block() = default;

  /// \}

  /// \name Not implemented
  /// \{

    virtual const ArgumentVector& get_parameters() const {
      throw std::runtime_error("get_parameters not implemented");
    }


  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Block
   * \return true as object is of type ast::Block
   */
  bool is_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Block* clone() const override {
    return new Block(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Block"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Block";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Block>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Block>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BLOCK_HPP
#ifndef NMODL_AST_IDENTIFIER_HPP
#define NMODL_AST_IDENTIFIER_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all identifiers
 *
 * Base class for all variable types like ast::Name, ast::PrimeName and ast::Argument.
  * 
  * \sa ast::Number
  * 
*/
class Identifier : public Expression {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Identifier() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Identifier
   * \return true as object is of type ast::Identifier
   */
  bool is_identifier () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Identifier* clone() const override {
    return new Identifier(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::IDENTIFIER
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::IDENTIFIER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Identifier"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Identifier";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Identifier>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Identifier>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_IDENTIFIER_HPP
#ifndef NMODL_AST_NUMBER_HPP
#define NMODL_AST_NUMBER_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Base class for all numbers
 *
 * Base class for all number types like ast::Integer, ast::Float and ast::Double.
  * 
*/
class Number : public Expression {

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Number() = default;

  /// \}

  /// \name Not implemented
  /// \{


     virtual double to_double() {
      throw std::runtime_error("to_double not implemented");
    }

  /// \}

  /**
   * \brief Check if the ast node is an instance of ast::Number
   * \return true as object is of type ast::Number
   */
  bool is_number () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   virtual  Number* clone() const override {
    return new Number(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NUMBER
   *
   * \sa Ast::get_node_type_name
   */
   virtual  AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NUMBER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Number"
   *
   * \sa Ast::get_node_name
   */
   virtual  std::string get_node_type_name() const noexcept override {
    return "Number";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Number>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   virtual  std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Number>(shared_from_this());
  }





  /// \}







  

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   virtual  void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   virtual  void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   virtual  void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NUMBER_HPP
#ifndef NMODL_AST_STRING_HPP
#define NMODL_AST_STRING_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a string
 *
 * All statements encapsulating text block are stored in the AST as ast::String.
  * For example, nodes like ast::LineComment and ast::Verbatim block use ast::String::value
  * to store the underlying text:
  * 
  * \code{.mod}
  *     COMMENT
  *       This text is stored as String
  *     ENDCOMMENT
  * 
  *     VERBATIM
  *         int *x;
  *         *x = ...
  *     ENDVERBATIM
  * \endcode
  * 
*/
class String : public Expression {
  private:
    /// Value of string
      std::string value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit String(const std::string& value);
    String(const String& obj);

    String() = default;

  virtual ~String() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::String
   * \return true as object is of type ast::String
   */
  bool is_string () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   String* clone() const override {
    return new String(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STRING
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STRING;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "String"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "String";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<String>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const String>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref String.value
                    */
                   const std::string& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }


    /**
     * \brief Set new value to the current ast node
     * \sa String::eval
     */
    void set(std::string _value) {
      value = _value;
    }

    
                       /**
                        * \brief Setter for member variable \ref String.value
                        */
                       void set_value(std::string value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return value of the ast node
       *
       * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
       * to their literal values. This method is used to access underlying
       * literal value.
       *
       * \sa String::set
       */
      std::string eval() const {
        return value;
      }

  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STRING_HPP
#ifndef NMODL_AST_INTEGER_HPP
#define NMODL_AST_INTEGER_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents an integer variable
 *
 * Non floating value in the mod file is parsed as an integer. For example,
  * in the below code, integer literals like `0` and `11` are stored as ast::Integer
  * in the AST :
  * 
  * \code{.mod}
  *     FROM i=0 TO N {
  *         tau = X[i] + 11
  *     }
  * \endcode
  * 
  * \sa ast::Float ast::Double
  * 
*/
class Integer : public Number {
  private:
    /// Value of integer
      int value;
    /// if integer is a macro then it's name
      std::shared_ptr<Name> macro;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Integer(int value, Name* macro);
      explicit Integer(int value, const std::shared_ptr<Name>& macro);
    Integer(const Integer& obj);

    Integer() = default;

  virtual ~Integer() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Integer
   * \return true as object is of type ast::Integer
   */
  bool is_integer () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Integer* clone() const override {
    return new Integer(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INTEGER
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INTEGER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Integer"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Integer";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Integer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Integer>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Integer.value
                    */
                   int get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Integer.macro
                    */
                   const std::shared_ptr<Name>& get_macro() const noexcept  {
                       return macro;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }


    /**
     * \brief Set new value to the current ast node
     * \sa Integer::eval
     */
    void set(int _value) {
      value = _value;
    }

    
                       /**
                        * \brief Setter for member variable \ref Integer.value
                        */
                       void set_value(int value);
                    
    
                       /**
                        * \brief Setter for member variable \ref Integer.macro (rvalue reference)
                        */
                       void set_macro(std::shared_ptr<Name>&& macro);

                       /**
                        * \brief Setter for member variable \ref Integer.macro
                        */
                       void set_macro(const std::shared_ptr<Name>& macro);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}

    /**
     * \brief Negate the value of current ast node
     *
     * Parser parse `-x` in two parts : `x` and then `-`. Once second token
     * `-` is encountered, the corresponding value of ast node needs to be
     * multiplied by `-1` for ast::Number node types.
     */
    void negate() override {
        value = -value;
    }

    /**
     * \brief Return value of the current ast node as double
     */
    double to_double() override {
        return value;
    }

      /**
       * \brief Return value of the ast node
       *
       * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
       * to their literal values. This method is used to access underlying
       * literal value.
       *
       * \sa Integer::set
       */
      int eval() const {
        return value;
      }

  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INTEGER_HPP
#ifndef NMODL_AST_FLOAT_HPP
#define NMODL_AST_FLOAT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a float variable
 *
 * Single precision float value in the mod file can be represented by ast::Float.
  * 
  * \note Currently every float variable in the NMODL is stored as ast::Double and hence
  * this type is note used. This will be changed soon for variables like ast::ParamAssign.
  * 
  * \sa ast::Integer ast::Double
  * 
*/
class Float : public Number {
  private:
    /// Value of float
      std::string value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Float(const std::string& value);
    Float(const Float& obj);


  virtual ~Float() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Float
   * \return true as object is of type ast::Float
   */
  bool is_float () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Float* clone() const override {
    return new Float(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FLOAT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FLOAT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Float"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Float";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Float>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Float>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Float.value
                    */
                   const std::string& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }


    /**
     * \brief Set new value to the current ast node
     * \sa Float::eval
     */
    void set(std::string _value) {
      value = _value;
    }

    
                       /**
                        * \brief Setter for member variable \ref Float.value
                        */
                       void set_value(std::string value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}

    /**
     * \brief Negate the value of current ast node
     *
     * Parser parse `-x` in two parts : `x` and then `-`. Once second token
     * `-` is encountered, the corresponding value of ast node needs to be
     * multiplied by `-1` for ast::Number node types.
     */
    void negate() override {
        value = value.insert (0, 1, '-');
    }

    /**
     * \brief Return value of the current ast node as double
     */
    double to_double() override {
        return std::stod(value);
    }

      /**
       * \brief Return value of the ast node
       *
       * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
       * to their literal values. This method is used to access underlying
       * literal value.
       *
       * \sa Float::set
       */
      std::string eval() const {
        return value;
      }

  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FLOAT_HPP
#ifndef NMODL_AST_DOUBLE_HPP
#define NMODL_AST_DOUBLE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a double variable
 *
 * %Double precision float value in the mod file is represented by ast::Double.
  * For example, float literals like `0.1` in the mod file are parsed as double
  * and stored using ast::Double::value :
  * 
  * \code{.mod}
  *     PROCEDURE foo() {
  *       LOCAL x
  *       x = 0.1 + tau
  *     }
  * \endcode
  * 
  * Note that the variables are not classified ast integer or float in the AST. The
  * decision about variable types is done by code generation backends.
  * 
  * \sa ast::Integer ast::Float
  * 
*/
class Double : public Number {
  private:
    /// Value of double
      std::string value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Double(const std::string& value);
    Double(const Double& obj);

    Double() = default;

  virtual ~Double() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Double
   * \return true as object is of type ast::Double
   */
  bool is_double () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Double* clone() const override {
    return new Double(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DOUBLE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DOUBLE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Double"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Double";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Double>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Double>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Double.value
                    */
                   const std::string& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }


    /**
     * \brief Set new value to the current ast node
     * \sa Double::eval
     */
    void set(std::string _value) {
      value = _value;
    }

    
                       /**
                        * \brief Setter for member variable \ref Double.value
                        */
                       void set_value(std::string value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}

    /**
     * \brief Negate the value of current ast node
     *
     * Parser parse `-x` in two parts : `x` and then `-`. Once second token
     * `-` is encountered, the corresponding value of ast node needs to be
     * multiplied by `-1` for ast::Number node types.
     */
    void negate() override {
        value = value.insert (0, 1, '-');
    }

    /**
     * \brief Return value of the current ast node as double
     */
    double to_double() override {
        return std::stod(value);
    }

      /**
       * \brief Return value of the ast node
       *
       * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
       * to their literal values. This method is used to access underlying
       * literal value.
       *
       * \sa Double::set
       */
      std::string eval() const {
        return value;
      }

  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DOUBLE_HPP
#ifndef NMODL_AST_BOOLEAN_HPP
#define NMODL_AST_BOOLEAN_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a boolean variable
 *
 * %Boolean values in the mod file can be represented by ast::Boolean.
  * 
  * \note Currently this type is used as only flag in some of the AST nodes. Similar to ast::Float,
  * this type was introduced for data type specific code generation support in the future.
  * 
*/
class Boolean : public Number {
  private:
    /// Value of boolean
      int value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Boolean(int value);
    Boolean(const Boolean& obj);


  virtual ~Boolean() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Boolean
   * \return true as object is of type ast::Boolean
   */
  bool is_boolean () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Boolean* clone() const override {
    return new Boolean(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BOOLEAN
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BOOLEAN;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Boolean"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Boolean";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Boolean>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Boolean>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Boolean.value
                    */
                   int get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }


    /**
     * \brief Set new value to the current ast node
     * \sa Boolean::eval
     */
    void set(bool _value) {
      value = _value;
    }

    
                       /**
                        * \brief Setter for member variable \ref Boolean.value
                        */
                       void set_value(int value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}

    /**
     * \brief Negate the value of current ast node
     *
     * Parser parse `-x` in two parts : `x` and then `-`. Once second token
     * `-` is encountered, the corresponding value of ast node needs to be
     * multiplied by `-1` for ast::Number node types.
     */
    void negate() override {
        value = !value;
    }

    /**
     * \brief Return value of the current ast node as double
     */
    double to_double() override {
        return value;
    }

      /**
       * \brief Return value of the ast node
       *
       * Base data type nodes like ast::Inetegr, ast::Double can be evaluated
       * to their literal values. This method is used to access underlying
       * literal value.
       *
       * \sa Boolean::set
       */
      bool eval() const {
        return value;
      }

  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BOOLEAN_HPP
#ifndef NMODL_AST_NAME_HPP
#define NMODL_AST_NAME_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a name
 *
 * Whenever lexer encounters string variable, it returns a ast::Name
  * type. So, along with ast::Integer, ast::Double ast::String and ast::PrimeName,
  * ast::Name is one of the fundamental type in the AST. Many other variable types
  * (e.g. ast::GlobalVar, ast::RangeVar) have underlying value stored as ast::Name.
  * 
  * \note This node should be able to use std::string as value type instead of ast::String
  * 
*/
class Name : public Identifier {
  private:
    /// Value of name
      std::shared_ptr<String> value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Name(String* value);
      explicit Name(const std::shared_ptr<String>& value);
    Name(const Name& obj);

    Name() = default;

  virtual ~Name() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Name
   * \return true as object is of type ast::Name
   */
  bool is_name () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Name* clone() const override {
    return new Name(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NAME
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Name"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Name";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Name>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Name>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::String has value designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Name.value
                    */
                   const std::shared_ptr<String>& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{

    /**
     * \brief Set name for the current ast node
     *
     * Some ast nodes have a member marked designated as node name (e.g. nodes
     * derived from ast::Identifier). This method is used to set new name for those
     * nodes. This useful for passes like nmodl::visitor::RenameVisitor.
     *
     * \sa Ast::get_node_type_name Ast::get_node_name
     */
    void set_name(const std::string& name) override;

    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Name.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<String>&& value);

                       /**
                        * \brief Setter for member variable \ref Name.value
                        */
                       void set_value(const std::shared_ptr<String>& value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NAME_HPP
#ifndef NMODL_AST_PRIME_NAME_HPP
#define NMODL_AST_PRIME_NAME_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a prime variable (for ODE)
 *
 * In case of ODE specification, all state variables appearing on LHS
  * with \` as suffix are parsed by lexer as ast::PrimeName. For example,
  * in below NMODL construct, m\` is stored as ast::PrimeName with `m` as a
  * ast::PrimeName::value and `1` as an ast::PrimeName::order.
  * 
  * \code
  *     DERIVATIVE states {
  *       m` = m + h
  *     }
  * \endcode
  * 
*/
class PrimeName : public Identifier {
  private:
    /// Name of prime variable
      std::shared_ptr<String> value;
    /// order of ODE
      std::shared_ptr<Integer> order;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PrimeName(String* value, Integer* order);
      explicit PrimeName(const std::shared_ptr<String>& value, const std::shared_ptr<Integer>& order);
    PrimeName(const PrimeName& obj);

    PrimeName() = default;

  virtual ~PrimeName() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PrimeName
   * \return true as object is of type ast::PrimeName
   */
  bool is_prime_name () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PrimeName* clone() const override {
    return new PrimeName(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PRIME_NAME
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PRIME_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PrimeName"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PrimeName";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PrimeName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PrimeName>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::String has value designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref PrimeName.value
                    */
                   const std::shared_ptr<String>& get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PrimeName.order
                    */
                   const std::shared_ptr<Integer>& get_order() const noexcept  {
                       return order;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PrimeName.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<String>&& value);

                       /**
                        * \brief Setter for member variable \ref PrimeName.value
                        */
                       void set_value(const std::shared_ptr<String>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref PrimeName.order (rvalue reference)
                        */
                       void set_order(std::shared_ptr<Integer>&& order);

                       /**
                        * \brief Setter for member variable \ref PrimeName.order
                        */
                       void set_order(const std::shared_ptr<Integer>& order);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PRIME_NAME_HPP
#ifndef NMODL_AST_INDEXED_NAME_HPP
#define NMODL_AST_INDEXED_NAME_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents specific element of an array variable
 *
 * If variable is declared as an array or when array element is accessed,
  * it is stored in the ast as ast::IndexedName. For example, in below NMODL,
  * construct `m[4]` is stored as ast::IndexedName with `m` as ast::IndexedName::name
  * and `4` as ast::IndexedName::legth.
  * 
  * \code
  *     STATE {
  *       m[4]
  *     }
  * \endcode
  * 
*/
class IndexedName : public Identifier {
  private:
    /// Name of array variable
      std::shared_ptr<Identifier> name;
    /// legth of an array or index position
      std::shared_ptr<Expression> length;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit IndexedName(Identifier* name, Expression* length);
      explicit IndexedName(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Expression>& length);
    IndexedName(const IndexedName& obj);


  virtual ~IndexedName() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::IndexedName
   * \return true as object is of type ast::IndexedName
   */
  bool is_indexed_name () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   IndexedName* clone() const override {
    return new IndexedName(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEXED_NAME
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEXED_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndexedName"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "IndexedName";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndexedName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndexedName>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref IndexedName.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndexedName.length
                    */
                   const std::shared_ptr<Expression>& get_length() const noexcept  {
                       return length;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref IndexedName.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref IndexedName.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndexedName.length (rvalue reference)
                        */
                       void set_length(std::shared_ptr<Expression>&& length);

                       /**
                        * \brief Setter for member variable \ref IndexedName.length
                        */
                       void set_length(const std::shared_ptr<Expression>& length);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INDEXED_NAME_HPP
#ifndef NMODL_AST_VAR_NAME_HPP
#define NMODL_AST_VAR_NAME_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a variable
 *
 * This type was introduced to store variables of different types like
  * ast::Name or ast::IndexedName in the AST.
  * 
  * \note With ast::Identifier as top level base class, this type can be
  * removed in the future refactoring.
  * 
*/
class VarName : public Identifier {
  private:
    /// Name of variable
      std::shared_ptr<Identifier> name;
    /// Value specified with `@`
      std::shared_ptr<Integer> at;
    /// index value in case of array
      std::shared_ptr<Expression> index;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit VarName(Identifier* name, Integer* at, Expression* index);
      explicit VarName(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Integer>& at, const std::shared_ptr<Expression>& index);
    VarName(const VarName& obj);


  virtual ~VarName() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::VarName
   * \return true as object is of type ast::VarName
   */
  bool is_var_name () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   VarName* clone() const override {
    return new VarName(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VAR_NAME
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VAR_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "VarName"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "VarName";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<VarName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const VarName>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref VarName.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref VarName.at
                    */
                   const std::shared_ptr<Integer>& get_at() const noexcept  {
                       return at;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref VarName.index
                    */
                   const std::shared_ptr<Expression>& get_index() const noexcept  {
                       return index;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref VarName.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref VarName.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref VarName.at (rvalue reference)
                        */
                       void set_at(std::shared_ptr<Integer>&& at);

                       /**
                        * \brief Setter for member variable \ref VarName.at
                        */
                       void set_at(const std::shared_ptr<Integer>& at);
                    
    
                       /**
                        * \brief Setter for member variable \ref VarName.index (rvalue reference)
                        */
                       void set_index(std::shared_ptr<Expression>&& index);

                       /**
                        * \brief Setter for member variable \ref VarName.index
                        */
                       void set_index(const std::shared_ptr<Expression>& index);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_VAR_NAME_HPP
#ifndef NMODL_AST_ARGUMENT_HPP
#define NMODL_AST_ARGUMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents an argument to functions and procedures
 *
 * In case of function definitions from different ast nodes like ast::FunctionBlock,
  * ast::ProcedureBlock, the arguments are store in the ast::Argument. For example,
  * in below NMODL construct, `weight` is stored as ast::Argument::name and `uS` is
  * stored as ast::Argument::unit:
  * 
  * \code {.mod}
  *     NET_RECEIVE(weight (uS)) {
  *         g = g + weight
  *     }
  * \endcode
  * 
*/
class Argument : public Identifier {
  private:
    /// Name of the argument
      std::shared_ptr<Identifier> name;
    /// Unit of the argument
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Argument(Identifier* name, Unit* unit);
      explicit Argument(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Unit>& unit);
    Argument(const Argument& obj);


  virtual ~Argument() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Argument
   * \return true as object is of type ast::Argument
   */
  bool is_argument () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Argument* clone() const override {
    return new Argument(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ARGUMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ARGUMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Argument"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Argument";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Argument>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Argument>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Argument.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Argument.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Argument.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref Argument.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Argument.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref Argument.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ARGUMENT_HPP
#ifndef NMODL_AST_REACT_VAR_NAME_HPP
#define NMODL_AST_REACT_VAR_NAME_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ReactVarName : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Integer> value;
    /// TODO
      std::shared_ptr<VarName> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ReactVarName(Integer* value, VarName* name);
      explicit ReactVarName(const std::shared_ptr<Integer>& value, const std::shared_ptr<VarName>& name);
    ReactVarName(const ReactVarName& obj);


  virtual ~ReactVarName() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ReactVarName
   * \return true as object is of type ast::ReactVarName
   */
  bool is_react_var_name () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ReactVarName* clone() const override {
    return new ReactVarName(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACT_VAR_NAME
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACT_VAR_NAME;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactVarName"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ReactVarName";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactVarName>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactVarName>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactVarName.value
                    */
                   const std::shared_ptr<Integer>& get_value() const noexcept  {
                       return value;
                   }
                

    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::VarName has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ReactVarName.name
                    */
                   const std::shared_ptr<VarName>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ReactVarName.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Integer>&& value);

                       /**
                        * \brief Setter for member variable \ref ReactVarName.value
                        */
                       void set_value(const std::shared_ptr<Integer>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref ReactVarName.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<VarName>&& name);

                       /**
                        * \brief Setter for member variable \ref ReactVarName.name
                        */
                       void set_name(const std::shared_ptr<VarName>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_REACT_VAR_NAME_HPP
#ifndef NMODL_AST_READ_ION_VAR_HPP
#define NMODL_AST_READ_ION_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ReadIonVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ReadIonVar(Name* name);
      explicit ReadIonVar(const std::shared_ptr<Name>& name);
    ReadIonVar(const ReadIonVar& obj);


  virtual ~ReadIonVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ReadIonVar
   * \return true as object is of type ast::ReadIonVar
   */
  bool is_read_ion_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ReadIonVar* clone() const override {
    return new ReadIonVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::READ_ION_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::READ_ION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReadIonVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ReadIonVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReadIonVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReadIonVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ReadIonVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ReadIonVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ReadIonVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_READ_ION_VAR_HPP
#ifndef NMODL_AST_WRITE_ION_VAR_HPP
#define NMODL_AST_WRITE_ION_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class WriteIonVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit WriteIonVar(Name* name);
      explicit WriteIonVar(const std::shared_ptr<Name>& name);
    WriteIonVar(const WriteIonVar& obj);


  virtual ~WriteIonVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::WriteIonVar
   * \return true as object is of type ast::WriteIonVar
   */
  bool is_write_ion_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   WriteIonVar* clone() const override {
    return new WriteIonVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WRITE_ION_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WRITE_ION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WriteIonVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "WriteIonVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WriteIonVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WriteIonVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref WriteIonVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref WriteIonVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref WriteIonVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_WRITE_ION_VAR_HPP
#ifndef NMODL_AST_NONSPECIFIC_CUR_VAR_HPP
#define NMODL_AST_NONSPECIFIC_CUR_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class NonspecificCurVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NonspecificCurVar(Name* name);
      explicit NonspecificCurVar(const std::shared_ptr<Name>& name);
    NonspecificCurVar(const NonspecificCurVar& obj);


  virtual ~NonspecificCurVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NonspecificCurVar
   * \return true as object is of type ast::NonspecificCurVar
   */
  bool is_nonspecific_cur_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NonspecificCurVar* clone() const override {
    return new NonspecificCurVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NONSPECIFIC_CUR_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NONSPECIFIC_CUR_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonspecificCurVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NonspecificCurVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonspecificCurVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonspecificCurVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref NonspecificCurVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref NonspecificCurVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref NonspecificCurVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NONSPECIFIC_CUR_VAR_HPP
#ifndef NMODL_AST_ELECTRODE_CUR_VAR_HPP
#define NMODL_AST_ELECTRODE_CUR_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ElectrodeCurVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ElectrodeCurVar(Name* name);
      explicit ElectrodeCurVar(const std::shared_ptr<Name>& name);
    ElectrodeCurVar(const ElectrodeCurVar& obj);


  virtual ~ElectrodeCurVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ElectrodeCurVar
   * \return true as object is of type ast::ElectrodeCurVar
   */
  bool is_electrode_cur_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ElectrodeCurVar* clone() const override {
    return new ElectrodeCurVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELECTRODE_CUR_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELECTRODE_CUR_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElectrodeCurVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ElectrodeCurVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElectrodeCurVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElectrodeCurVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ElectrodeCurVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ElectrodeCurVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ElectrodeCurVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ELECTRODE_CUR_VAR_HPP
#ifndef NMODL_AST_SECTION_VAR_HPP
#define NMODL_AST_SECTION_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class SectionVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit SectionVar(Name* name);
      explicit SectionVar(const std::shared_ptr<Name>& name);
    SectionVar(const SectionVar& obj);


  virtual ~SectionVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::SectionVar
   * \return true as object is of type ast::SectionVar
   */
  bool is_section_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   SectionVar* clone() const override {
    return new SectionVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SECTION_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SECTION_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SectionVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "SectionVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SectionVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SectionVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref SectionVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref SectionVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref SectionVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SECTION_VAR_HPP
#ifndef NMODL_AST_RANGE_VAR_HPP
#define NMODL_AST_RANGE_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class RangeVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit RangeVar(Name* name);
      explicit RangeVar(const std::shared_ptr<Name>& name);
    RangeVar(const RangeVar& obj);


  virtual ~RangeVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::RangeVar
   * \return true as object is of type ast::RangeVar
   */
  bool is_range_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   RangeVar* clone() const override {
    return new RangeVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RANGE_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RANGE_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "RangeVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "RangeVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<RangeVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const RangeVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref RangeVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref RangeVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref RangeVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_RANGE_VAR_HPP
#ifndef NMODL_AST_GLOBAL_VAR_HPP
#define NMODL_AST_GLOBAL_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class GlobalVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit GlobalVar(Name* name);
      explicit GlobalVar(const std::shared_ptr<Name>& name);
    GlobalVar(const GlobalVar& obj);


  virtual ~GlobalVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::GlobalVar
   * \return true as object is of type ast::GlobalVar
   */
  bool is_global_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   GlobalVar* clone() const override {
    return new GlobalVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::GLOBAL_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::GLOBAL_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "GlobalVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "GlobalVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<GlobalVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const GlobalVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref GlobalVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref GlobalVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref GlobalVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_GLOBAL_VAR_HPP
#ifndef NMODL_AST_POINTER_VAR_HPP
#define NMODL_AST_POINTER_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PointerVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PointerVar(Name* name);
      explicit PointerVar(const std::shared_ptr<Name>& name);
    PointerVar(const PointerVar& obj);


  virtual ~PointerVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PointerVar
   * \return true as object is of type ast::PointerVar
   */
  bool is_pointer_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PointerVar* clone() const override {
    return new PointerVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::POINTER_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::POINTER_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PointerVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PointerVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PointerVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PointerVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref PointerVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PointerVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref PointerVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_POINTER_VAR_HPP
#ifndef NMODL_AST_BBCORE_POINTER_VAR_HPP
#define NMODL_AST_BBCORE_POINTER_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent a single variable of type BBCOREPOINTER
 *
 * See ast::BbcorePointer for an example.
  * 
*/
class BbcorePointerVar : public Identifier {
  private:
    /// Variable name
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BbcorePointerVar(Name* name);
      explicit BbcorePointerVar(const std::shared_ptr<Name>& name);
    BbcorePointerVar(const BbcorePointerVar& obj);


  virtual ~BbcorePointerVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointerVar
   * \return true as object is of type ast::BbcorePointerVar
   */
  bool is_bbcore_pointer_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BbcorePointerVar* clone() const override {
    return new BbcorePointerVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BBCORE_POINTER_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BBCORE_POINTER_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BbcorePointerVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BbcorePointerVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BbcorePointerVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BbcorePointerVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref BbcorePointerVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BbcorePointerVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref BbcorePointerVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BBCORE_POINTER_VAR_HPP
#ifndef NMODL_AST_EXTERN_VAR_HPP
#define NMODL_AST_EXTERN_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ExternVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ExternVar(Name* name);
      explicit ExternVar(const std::shared_ptr<Name>& name);
    ExternVar(const ExternVar& obj);


  virtual ~ExternVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ExternVar
   * \return true as object is of type ast::ExternVar
   */
  bool is_extern_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ExternVar* clone() const override {
    return new ExternVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXTERN_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXTERN_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ExternVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ExternVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ExternVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ExternVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ExternVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ExternVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ExternVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EXTERN_VAR_HPP
#ifndef NMODL_AST_THREADSAFE_VAR_HPP
#define NMODL_AST_THREADSAFE_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ThreadsafeVar : public Identifier {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ThreadsafeVar(Name* name);
      explicit ThreadsafeVar(const std::shared_ptr<Name>& name);
    ThreadsafeVar(const ThreadsafeVar& obj);


  virtual ~ThreadsafeVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ThreadsafeVar
   * \return true as object is of type ast::ThreadsafeVar
   */
  bool is_threadsafe_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ThreadsafeVar* clone() const override {
    return new ThreadsafeVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::THREADSAFE_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::THREADSAFE_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ThreadsafeVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ThreadsafeVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ThreadsafeVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ThreadsafeVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ThreadsafeVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ThreadsafeVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ThreadsafeVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_THREADSAFE_VAR_HPP
#ifndef NMODL_AST_PARAM_BLOCK_HPP
#define NMODL_AST_PARAM_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `PARAMETER` block in the NMODL
 *
 * Variables whose values are normally specified by the user are parameters
  * and are declared in a `PARAMETER` block. Here is an example :
  * 
  * \code{.mod}
  *     PARAMETER {
  *         gkbar=.01   (mho/cm2) : Maximum Permeability
  *         d1 = .84
  *         k2 = .13e-6 (mM)
  *         abar = .28  (/ms)
  *         lcai (mV)
  *     }
  * \endcode
  * 
  * All parameters are stored in the ast::ParamBlock::statements as vector.
  * 
*/
class ParamBlock : public Block {
  private:
    /// Vector of parameters
      ParamAssignVector statements;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ParamBlock(ParamAssignVector statements);
    ParamBlock(const ParamBlock& obj);


  virtual ~ParamBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ParamBlock
   * \return true as object is of type ast::ParamBlock
   */
  bool is_param_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ParamBlock* clone() const override {
    return new ParamBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARAM_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARAM_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParamBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ParamBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "PARAMETER "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "PARAMETER ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParamBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParamBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ParamBlock.statements
                    */
                   const ParamAssignVector& get_statements() const noexcept  {
                       return statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref ParamBlock.statements (rvalue reference)
                        */
                       void set_statements(ParamAssignVector&& statements);

                       /**
                        * \brief Setter for member variable \ref ParamBlock.statements
                        */
                       void set_statements(const ParamAssignVector& statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PARAM_BLOCK_HPP
#ifndef NMODL_AST_STEP_BLOCK_HPP
#define NMODL_AST_STEP_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `STEPPED` block in the NMODL
 *
 * `STEPPED` has following form in the NMODL specification :
  * 
  * \code{.mod}
  *     STEPPED {
  *         name1 = number1 (mM)
  *         name2 = number2, number3
  *     }
  * \endcode
  * 
  * \todo Check ModelDB and other databse for example of channel.
  * 
*/
class StepBlock : public Block {
  private:
    /// Vector of statements
      SteppedVector statements;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit StepBlock(SteppedVector statements);
    StepBlock(const StepBlock& obj);


  virtual ~StepBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::StepBlock
   * \return true as object is of type ast::StepBlock
   */
  bool is_step_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   StepBlock* clone() const override {
    return new StepBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STEP_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STEP_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StepBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "StepBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "STEPPED "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "STEPPED ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StepBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StepBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref StepBlock.statements
                    */
                   const SteppedVector& get_statements() const noexcept  {
                       return statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref StepBlock.statements (rvalue reference)
                        */
                       void set_statements(SteppedVector&& statements);

                       /**
                        * \brief Setter for member variable \ref StepBlock.statements
                        */
                       void set_statements(const SteppedVector& statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STEP_BLOCK_HPP
#ifndef NMODL_AST_INDEPENDENT_BLOCK_HPP
#define NMODL_AST_INDEPENDENT_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `INDEPENDENT` block in the NMODL
 *
 * `INDEPENDENT` has following form in the NMODL specification :
  * 
  * \code{.mod}
  *     INDEPENDENT {
  *       t FROM 0 TO 1 WITH 1 (ms)
  *     }
  * \endcode
  * 
*/
class IndependentBlock : public Block {
  private:
    /// TODO
      IndependentDefinitionVector definitions;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit IndependentBlock(IndependentDefinitionVector definitions);
    IndependentBlock(const IndependentBlock& obj);


  virtual ~IndependentBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::IndependentBlock
   * \return true as object is of type ast::IndependentBlock
   */
  bool is_independent_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   IndependentBlock* clone() const override {
    return new IndependentBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEPENDENT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEPENDENT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndependentBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "IndependentBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "INDEPENDENT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "INDEPENDENT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndependentBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndependentBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentBlock.definitions
                    */
                   const IndependentDefinitionVector& get_definitions() const noexcept  {
                       return definitions;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref IndependentBlock.definitions (rvalue reference)
                        */
                       void set_definitions(IndependentDefinitionVector&& definitions);

                       /**
                        * \brief Setter for member variable \ref IndependentBlock.definitions
                        */
                       void set_definitions(const IndependentDefinitionVector& definitions);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INDEPENDENT_BLOCK_HPP
#ifndef NMODL_AST_ASSIGNED_BLOCK_HPP
#define NMODL_AST_ASSIGNED_BLOCK_HPP
#define NMODL_AST_ASSIGNED_BLOCK_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `ASSIGNED` block in the NMODL
 *
 * The `ASSIGNED` block is used for declaring two kinds of variables :
  *   - those that are given values outside the mod files
  *   - those that appear on the left hand side of assignment statements within
  *     the mod file
  * 
  * Below is an example of `ASSIGNED` block in the mod file:
  * 
  * \code{.mod}
  *     ASSIGNED {
  *         ina     (mA/cm2)
  *         gna     (pS/um2)
  *         mtau (ms)   htau (ms)
  *         tadj
  *     }
  * \endcode
  * 
*/
class AssignedBlock : public Block {
  private:
    /// Vector of assigned variables
      AssignedDefinitionVector definitions;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit AssignedBlock(AssignedDefinitionVector definitions);
    AssignedBlock(const AssignedBlock& obj);


  virtual ~AssignedBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::AssignedBlock
   * \return true as object is of type ast::AssignedBlock
   */
  bool is_assigned_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   AssignedBlock* clone() const override {
    return new AssignedBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ASSIGNED_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ASSIGNED_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AssignedBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "AssignedBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "ASSIGNED "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "ASSIGNED ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AssignedBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AssignedBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    
/**
 * \brief Add member to definitions by raw pointer
 */
void emplace_back_assigned_definition(AssignedDefinition *n);

/**
 * \brief Add member to definitions by shared_ptr
 */
void emplace_back_assigned_definition(std::shared_ptr<AssignedDefinition> n);

/**
 * \brief Erase member to definitions
 */
AssignedDefinitionVector::const_iterator erase_assigned_definition(AssignedDefinitionVector::const_iterator first);

/**
 * \brief Erase members to definitions
 */
AssignedDefinitionVector::const_iterator erase_assigned_definition(AssignedDefinitionVector::const_iterator first, AssignedDefinitionVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to definitions
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_assigned_definition(std::unordered_set<AssignedDefinition*>& to_be_erased);

/**
 * \brief Insert member to definitions
 */
AssignedDefinitionVector::const_iterator insert_assigned_definition(AssignedDefinitionVector::const_iterator position, const std::shared_ptr<AssignedDefinition>& n);

/**
 * \brief Insert members to definitions
 */
template <class NodeType, class InputIterator>
void insert_assigned_definition(AssignedDefinitionVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to definitions
 */
void reset_assigned_definition(AssignedDefinitionVector::const_iterator position, AssignedDefinition* n);

/**
 * \brief Reset member to definitions
 */
void reset_assigned_definition(AssignedDefinitionVector::const_iterator position, std::shared_ptr<AssignedDefinition> n);


    

    
                   /**
                    * \brief Getter for member variable \ref AssignedBlock.definitions
                    */
                   const AssignedDefinitionVector& get_definitions() const noexcept  {
                       return definitions;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref AssignedBlock.definitions (rvalue reference)
                        */
                       void set_definitions(AssignedDefinitionVector&& definitions);

                       /**
                        * \brief Setter for member variable \ref AssignedBlock.definitions
                        */
                       void set_definitions(const AssignedDefinitionVector& definitions);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ASSIGNED_BLOCK_HPP
#ifndef NMODL_AST_STATE_BLOCK_HPP
#define NMODL_AST_STATE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `STATE` block in the NMODL
 *
 * If a model involves differential equations, families of algebraic equations,
  * or kinetic reaction schemes, their dependent variables or unknowns are to be
  * listed in the `STATE` block. Below is an example of `STATE`:
  * 
  *   \code{.mod}
  *       STATE {
  *           m
  *           h
  *       }
  *   \endcode
  * 
  *   Note that the state variable specification has form of ast::AssignedDefinition and
  *   hence can have associated unit specification.
  * 
*/
class StateBlock : public Block {
  private:
    /// Vector of state variables
      AssignedDefinitionVector definitions;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit StateBlock(AssignedDefinitionVector definitions);
    StateBlock(const StateBlock& obj);


  virtual ~StateBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::StateBlock
   * \return true as object is of type ast::StateBlock
   */
  bool is_state_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   StateBlock* clone() const override {
    return new StateBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StateBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "StateBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "STATE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "STATE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StateBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StateBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref StateBlock.definitions
                    */
                   const AssignedDefinitionVector& get_definitions() const noexcept  {
                       return definitions;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref StateBlock.definitions (rvalue reference)
                        */
                       void set_definitions(AssignedDefinitionVector&& definitions);

                       /**
                        * \brief Setter for member variable \ref StateBlock.definitions
                        */
                       void set_definitions(const AssignedDefinitionVector& definitions);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STATE_BLOCK_HPP
#ifndef NMODL_AST_PLOT_BLOCK_HPP
#define NMODL_AST_PLOT_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `PLOT` statement in the NMODL
 *
 * `PLOT` construct doesn't have block scope but it's standalone, global scoped
  * statement of the form:
  * 
  *   \code{.mod}
  *       PLOT name1, index_var2 VS name3
  *   \endcode
  * 
  *   \todo Check ModelDB and other databse for example of channel.
  * 
*/
class PlotBlock : public Block {
  private:
    /// Vector of plot variables
      std::shared_ptr<PlotDeclaration> plot;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PlotBlock(PlotDeclaration* plot);
      explicit PlotBlock(const std::shared_ptr<PlotDeclaration>& plot);
    PlotBlock(const PlotBlock& obj);


  virtual ~PlotBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PlotBlock
   * \return true as object is of type ast::PlotBlock
   */
  bool is_plot_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PlotBlock* clone() const override {
    return new PlotBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PlotBlock";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref PlotBlock.plot
                    */
                   const std::shared_ptr<PlotDeclaration>& get_plot() const noexcept  {
                       return plot;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref PlotBlock.plot (rvalue reference)
                        */
                       void set_plot(std::shared_ptr<PlotDeclaration>&& plot);

                       /**
                        * \brief Setter for member variable \ref PlotBlock.plot
                        */
                       void set_plot(const std::shared_ptr<PlotDeclaration>& plot);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PLOT_BLOCK_HPP
#ifndef NMODL_AST_INITIAL_BLOCK_HPP
#define NMODL_AST_INITIAL_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `INITIAL` block in the NMODL
 *
 * The code in the `INITIAL` block is executed when the hoc function `finitialize()`
  * is called. Here is an example :
  * 
  *   \code{.mod}
  *       INITIAL {
  *           rates(v+vshift)
  *           m = minf
  *           h = hinf
  *           tadj = q10^((celsius - temp)/10)
  *       }
  *   \endcode
  * 
*/
class InitialBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit InitialBlock(StatementBlock* statement_block);
      explicit InitialBlock(const std::shared_ptr<StatementBlock>& statement_block);
    InitialBlock(const InitialBlock& obj);


  virtual ~InitialBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::InitialBlock
   * \return true as object is of type ast::InitialBlock
   */
  bool is_initial_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   InitialBlock* clone() const override {
    return new InitialBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INITIAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INITIAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "InitialBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "InitialBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "INITIAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "INITIAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<InitialBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const InitialBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref InitialBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref InitialBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref InitialBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INITIAL_BLOCK_HPP
#ifndef NMODL_AST_CONSTRUCTOR_BLOCK_HPP
#define NMODL_AST_CONSTRUCTOR_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `CONSTRUCTOR` block in the NMODL
 *
 * The code in the `CONSTRUCTOR` is called when the channel is instantiated. Like any
  * other global block, `CONSTRUCTOR` block can have any statements. It often used with
  * `VERBATIM` block for initialization purpose :
  * 
  *   \code{.mod}
  *       CONSTRUCTOR {
  *           VERBATIM
  *             if (ifarg(1)) { id= *getarg(1); } else { id= -1; }
  *           ENDVERBATIM
  *       }
  *   \endcode
  * 
  *   \sa ast::DestructorBlock
  * 
*/
class ConstructorBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ConstructorBlock(StatementBlock* statement_block);
      explicit ConstructorBlock(const std::shared_ptr<StatementBlock>& statement_block);
    ConstructorBlock(const ConstructorBlock& obj);


  virtual ~ConstructorBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ConstructorBlock
   * \return true as object is of type ast::ConstructorBlock
   */
  bool is_constructor_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ConstructorBlock* clone() const override {
    return new ConstructorBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTRUCTOR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTRUCTOR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstructorBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ConstructorBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "CONSTRUCTOR "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "CONSTRUCTOR ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstructorBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstructorBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ConstructorBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref ConstructorBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ConstructorBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONSTRUCTOR_BLOCK_HPP
#ifndef NMODL_AST_DESTRUCTOR_BLOCK_HPP
#define NMODL_AST_DESTRUCTOR_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `DESTRUCTOR` block in the NMODL
 *
 * The code in the `DESTRUCTOR` is called when the channel instance is deleted. It often
  * used with `VERBATIM` block for finalization purpose :
  * 
  *   \code{.mod}
  *       DESTRUCTOR {
  *           VERBATIM {
  *               nsyn = maxsyn = 0;
  *               free(PRECAST);
  *               link = 0;
  *           }
  *           ENDVERBATIM
  *       }
  *   \endcode
  * 
  *   \sa ast::ConstructorBlock
  * 
*/
class DestructorBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DestructorBlock(StatementBlock* statement_block);
      explicit DestructorBlock(const std::shared_ptr<StatementBlock>& statement_block);
    DestructorBlock(const DestructorBlock& obj);


  virtual ~DestructorBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DestructorBlock
   * \return true as object is of type ast::DestructorBlock
   */
  bool is_destructor_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DestructorBlock* clone() const override {
    return new DestructorBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DESTRUCTOR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DESTRUCTOR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DestructorBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DestructorBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "DESTRUCTOR "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "DESTRUCTOR ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DestructorBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DestructorBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref DestructorBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref DestructorBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref DestructorBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DESTRUCTOR_BLOCK_HPP
#ifndef NMODL_AST_STATEMENT_BLOCK_HPP
#define NMODL_AST_STATEMENT_BLOCK_HPP
#define NMODL_AST_STATEMENT_BLOCK_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents block encapsulating list of statements
 *
 * Statement block is used to hold list of statements between `{ }`. This
  * represents a new block scope in the mod file and has following form :
  * 
  *   \code{.mod}
  *       {
  *           statement1
  *           {
  *             statement2
  *           }
  *       }
  *   \endcode
  * 
  *   Note that the statement blocks can be nested where inner block will
  *   be wrapped as statement with ast::ExpressionStatement.
  * 
*/
class StatementBlock : public Block {
  private:
    /// Vector of statements
      StatementVector statements;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit StatementBlock(StatementVector statements);
    StatementBlock(const StatementBlock& obj);


  virtual ~StatementBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::StatementBlock
   * \return true as object is of type ast::StatementBlock
   */
  bool is_statement_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   StatementBlock* clone() const override {
    return new StatementBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STATEMENT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STATEMENT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "StatementBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "StatementBlock";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<StatementBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const StatementBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    
/**
 * \brief Add member to statements by raw pointer
 */
void emplace_back_statement(Statement *n);

/**
 * \brief Add member to statements by shared_ptr
 */
void emplace_back_statement(std::shared_ptr<Statement> n);

/**
 * \brief Erase member to statements
 */
StatementVector::const_iterator erase_statement(StatementVector::const_iterator first);

/**
 * \brief Erase members to statements
 */
StatementVector::const_iterator erase_statement(StatementVector::const_iterator first, StatementVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to statements
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_statement(std::unordered_set<Statement*>& to_be_erased);

/**
 * \brief Insert member to statements
 */
StatementVector::const_iterator insert_statement(StatementVector::const_iterator position, const std::shared_ptr<Statement>& n);

/**
 * \brief Insert members to statements
 */
template <class NodeType, class InputIterator>
void insert_statement(StatementVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to statements
 */
void reset_statement(StatementVector::const_iterator position, Statement* n);

/**
 * \brief Reset member to statements
 */
void reset_statement(StatementVector::const_iterator position, std::shared_ptr<Statement> n);


    

    
                   /**
                    * \brief Getter for member variable \ref StatementBlock.statements
                    */
                   const StatementVector& get_statements() const noexcept  {
                       return statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref StatementBlock.statements (rvalue reference)
                        */
                       void set_statements(StatementVector&& statements);

                       /**
                        * \brief Setter for member variable \ref StatementBlock.statements
                        */
                       void set_statements(const StatementVector& statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STATEMENT_BLOCK_HPP
#ifndef NMODL_AST_DERIVATIVE_BLOCK_HPP
#define NMODL_AST_DERIVATIVE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `DERIVATIVE` block in the NMODL
 *
 * This block is used to assign values to the derivatives of those
  * `STATE`s that are described by differential equations. The statements
  * in this block are of the form \f$y' = expr\f$. Here is an example :
  * 
  *   \code{.mod}
  *       DERIVATIVE states {
  *           rates(v)
  *           m' =  (minf-m)/mtau
  *           h' = (hinf-h)/htau
  *       }
  *   \endcode
  * 
*/
class DerivativeBlock : public Block {
  private:
    /// Name of the derivative block
      std::shared_ptr<Name> name;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DerivativeBlock(Name* name, StatementBlock* statement_block);
      explicit DerivativeBlock(const std::shared_ptr<Name>& name, const std::shared_ptr<StatementBlock>& statement_block);
    DerivativeBlock(const DerivativeBlock& obj);


  virtual ~DerivativeBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DerivativeBlock
   * \return true as object is of type ast::DerivativeBlock
   */
  bool is_derivative_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DerivativeBlock* clone() const override {
    return new DerivativeBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DERIVATIVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DERIVATIVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DerivativeBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DerivativeBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "DERIVATIVE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "DERIVATIVE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DerivativeBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DerivativeBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref DerivativeBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref DerivativeBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref DerivativeBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref DerivativeBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref DerivativeBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref DerivativeBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DERIVATIVE_BLOCK_HPP
#ifndef NMODL_AST_LINEAR_BLOCK_HPP
#define NMODL_AST_LINEAR_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `LINEAR` block in the NMODL
 *
 * 
  * A set of simultaneous equations can be specified in a `LINEAR` block.
  * Here is an example :
  * 
  *   \code{.mod}
  *       LINEAR clamp {
  *           LOCAL t1, t2
  *           t1 = tau1/dt
  *           t2 = tau2/dt
  *           ~ vi = v + fac*vo - fac*v
  *           ~ t2*vo - t2*vo0 + vo = -gain * e
  *           ~ -stim - e  +  vi - e  +  t1*vi - t1*e - t1*(vi0 - e0) = 0
  *       }
  *   \endcode
  * 
*/
class LinearBlock : public Block {
  private:
    /// Name of the linear block
      std::shared_ptr<Name> name;
    /// TODO
      NameVector solvefor;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LinearBlock(Name* name, NameVector solvefor, StatementBlock* statement_block);
      explicit LinearBlock(const std::shared_ptr<Name>& name, const NameVector& solvefor, const std::shared_ptr<StatementBlock>& statement_block);
    LinearBlock(const LinearBlock& obj);


  virtual ~LinearBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LinearBlock
   * \return true as object is of type ast::LinearBlock
   */
  bool is_linear_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LinearBlock* clone() const override {
    return new LinearBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LINEAR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LINEAR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LinearBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LinearBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "LINEAR "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "LINEAR ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LinearBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LinearBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref LinearBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LinearBlock.solvefor
                    */
                   const NameVector& get_solvefor() const noexcept  {
                       return solvefor;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LinearBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref LinearBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref LinearBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref LinearBlock.solvefor (rvalue reference)
                        */
                       void set_solvefor(NameVector&& solvefor);

                       /**
                        * \brief Setter for member variable \ref LinearBlock.solvefor
                        */
                       void set_solvefor(const NameVector& solvefor);
                    
    
                       /**
                        * \brief Setter for member variable \ref LinearBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref LinearBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LINEAR_BLOCK_HPP
#ifndef NMODL_AST_NON_LINEAR_BLOCK_HPP
#define NMODL_AST_NON_LINEAR_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `NONLINEAR` block in the NMODL
 *
 * 
  * A set of simultaneous equations can be specified in a `NONLINEAR` block.
  * Here is an example :
  * 
  *   \code{.mod}
  *       NONLINEAR nonlin {
  *           ~ s[0] = 1
  *           ~ s[1] = 3
  *           ~ s[2] + s[1] = s[0]
  *       }
  *   \endcode
  * 
*/
class NonLinearBlock : public Block {
  private:
    /// Name of the non-linear block
      std::shared_ptr<Name> name;
    /// Name of the integration method
      NameVector solvefor;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NonLinearBlock(Name* name, NameVector solvefor, StatementBlock* statement_block);
      explicit NonLinearBlock(const std::shared_ptr<Name>& name, const NameVector& solvefor, const std::shared_ptr<StatementBlock>& statement_block);
    NonLinearBlock(const NonLinearBlock& obj);


  virtual ~NonLinearBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NonLinearBlock
   * \return true as object is of type ast::NonLinearBlock
   */
  bool is_non_linear_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NonLinearBlock* clone() const override {
    return new NonLinearBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NON_LINEAR_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NON_LINEAR_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonLinearBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NonLinearBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "NONLINEAR "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "NONLINEAR ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonLinearBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonLinearBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref NonLinearBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref NonLinearBlock.solvefor
                    */
                   const NameVector& get_solvefor() const noexcept  {
                       return solvefor;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref NonLinearBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.solvefor (rvalue reference)
                        */
                       void set_solvefor(NameVector&& solvefor);

                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.solvefor
                        */
                       void set_solvefor(const NameVector& solvefor);
                    
    
                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref NonLinearBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NON_LINEAR_BLOCK_HPP
#ifndef NMODL_AST_DISCRETE_BLOCK_HPP
#define NMODL_AST_DISCRETE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class DiscreteBlock : public Block {
  private:
    /// Name of the discrete block
      std::shared_ptr<Name> name;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DiscreteBlock(Name* name, StatementBlock* statement_block);
      explicit DiscreteBlock(const std::shared_ptr<Name>& name, const std::shared_ptr<StatementBlock>& statement_block);
    DiscreteBlock(const DiscreteBlock& obj);


  virtual ~DiscreteBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DiscreteBlock
   * \return true as object is of type ast::DiscreteBlock
   */
  bool is_discrete_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DiscreteBlock* clone() const override {
    return new DiscreteBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DISCRETE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DISCRETE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DiscreteBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DiscreteBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "DISCRETE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "DISCRETE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DiscreteBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DiscreteBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref DiscreteBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref DiscreteBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref DiscreteBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref DiscreteBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref DiscreteBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref DiscreteBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DISCRETE_BLOCK_HPP
#ifndef NMODL_AST_PARTIAL_BLOCK_HPP
#define NMODL_AST_PARTIAL_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PartialBlock : public Block {
  private:
    /// Name of the partial block
      std::shared_ptr<Name> name;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PartialBlock(Name* name, StatementBlock* statement_block);
      explicit PartialBlock(const std::shared_ptr<Name>& name, const std::shared_ptr<StatementBlock>& statement_block);
    PartialBlock(const PartialBlock& obj);


  virtual ~PartialBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PartialBlock
   * \return true as object is of type ast::PartialBlock
   */
  bool is_partial_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PartialBlock* clone() const override {
    return new PartialBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PartialBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "PARTIAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "PARTIAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref PartialBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref PartialBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref PartialBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref PartialBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PARTIAL_BLOCK_HPP
#ifndef NMODL_AST_FUNCTION_TABLE_BLOCK_HPP
#define NMODL_AST_FUNCTION_TABLE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FunctionTableBlock : public Block {
  private:
    /// Name of the function table block
      std::shared_ptr<Name> name;
    /// Vector of the parameters
      ArgumentVector parameters;
    /// Unit if specified
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FunctionTableBlock(Name* name, ArgumentVector parameters, Unit* unit);
      explicit FunctionTableBlock(const std::shared_ptr<Name>& name, const ArgumentVector& parameters, const std::shared_ptr<Unit>& unit);
    FunctionTableBlock(const FunctionTableBlock& obj);


  virtual ~FunctionTableBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FunctionTableBlock
   * \return true as object is of type ast::FunctionTableBlock
   */
  bool is_function_table_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FunctionTableBlock* clone() const override {
    return new FunctionTableBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_TABLE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_TABLE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionTableBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FunctionTableBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "FUNCTION_TABLE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "FUNCTION_TABLE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionTableBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionTableBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref FunctionTableBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionTableBlock.parameters
                    */
                   const ArgumentVector& get_parameters() const noexcept  override {
                       return parameters;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionTableBlock.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.parameters (rvalue reference)
                        */
                       void set_parameters(ArgumentVector&& parameters);

                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.parameters
                        */
                       void set_parameters(const ArgumentVector& parameters);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref FunctionTableBlock.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FUNCTION_TABLE_BLOCK_HPP
#ifndef NMODL_AST_FUNCTION_BLOCK_HPP
#define NMODL_AST_FUNCTION_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FunctionBlock : public Block {
  private:
    /// Name of the function
      std::shared_ptr<Name> name;
    /// Vector of the parameters
      ArgumentVector parameters;
    /// Unit if specified
      std::shared_ptr<Unit> unit;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FunctionBlock(Name* name, ArgumentVector parameters, Unit* unit, StatementBlock* statement_block);
      explicit FunctionBlock(const std::shared_ptr<Name>& name, const ArgumentVector& parameters, const std::shared_ptr<Unit>& unit, const std::shared_ptr<StatementBlock>& statement_block);
    FunctionBlock(const FunctionBlock& obj);


  virtual ~FunctionBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FunctionBlock
   * \return true as object is of type ast::FunctionBlock
   */
  bool is_function_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FunctionBlock* clone() const override {
    return new FunctionBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FunctionBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "FUNCTION "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "FUNCTION ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref FunctionBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionBlock.parameters
                    */
                   const ArgumentVector& get_parameters() const noexcept  override {
                       return parameters;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionBlock.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref FunctionBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref FunctionBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionBlock.parameters (rvalue reference)
                        */
                       void set_parameters(ArgumentVector&& parameters);

                       /**
                        * \brief Setter for member variable \ref FunctionBlock.parameters
                        */
                       void set_parameters(const ArgumentVector& parameters);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionBlock.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref FunctionBlock.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref FunctionBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FUNCTION_BLOCK_HPP
#ifndef NMODL_AST_PROCEDURE_BLOCK_HPP
#define NMODL_AST_PROCEDURE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ProcedureBlock : public Block {
  private:
    /// Name of the procedure
      std::shared_ptr<Name> name;
    /// Vector of the parameters
      ArgumentVector parameters;
    /// Unit if specified
      std::shared_ptr<Unit> unit;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ProcedureBlock(Name* name, ArgumentVector parameters, Unit* unit, StatementBlock* statement_block);
      explicit ProcedureBlock(const std::shared_ptr<Name>& name, const ArgumentVector& parameters, const std::shared_ptr<Unit>& unit, const std::shared_ptr<StatementBlock>& statement_block);
    ProcedureBlock(const ProcedureBlock& obj);


  virtual ~ProcedureBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ProcedureBlock
   * \return true as object is of type ast::ProcedureBlock
   */
  bool is_procedure_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ProcedureBlock* clone() const override {
    return new ProcedureBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROCEDURE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROCEDURE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ProcedureBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ProcedureBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "PROCEDURE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "PROCEDURE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ProcedureBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ProcedureBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ProcedureBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ProcedureBlock.parameters
                    */
                   const ArgumentVector& get_parameters() const noexcept  override {
                       return parameters;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ProcedureBlock.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ProcedureBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.parameters (rvalue reference)
                        */
                       void set_parameters(ArgumentVector&& parameters);

                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.parameters
                        */
                       void set_parameters(const ArgumentVector& parameters);
                    
    
                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    
    
                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ProcedureBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PROCEDURE_BLOCK_HPP
#ifndef NMODL_AST_NET_RECEIVE_BLOCK_HPP
#define NMODL_AST_NET_RECEIVE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class NetReceiveBlock : public Block {
  private:
    /// Parameters to the net receive block
      ArgumentVector parameters;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NetReceiveBlock(ArgumentVector parameters, StatementBlock* statement_block);
      explicit NetReceiveBlock(const ArgumentVector& parameters, const std::shared_ptr<StatementBlock>& statement_block);
    NetReceiveBlock(const NetReceiveBlock& obj);


  virtual ~NetReceiveBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NetReceiveBlock
   * \return true as object is of type ast::NetReceiveBlock
   */
  bool is_net_receive_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NetReceiveBlock* clone() const override {
    return new NetReceiveBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NET_RECEIVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NET_RECEIVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NetReceiveBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NetReceiveBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "NET_RECEIVE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "NET_RECEIVE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NetReceiveBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NetReceiveBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref NetReceiveBlock.parameters
                    */
                   const ArgumentVector& get_parameters() const noexcept  override {
                       return parameters;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref NetReceiveBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref NetReceiveBlock.parameters (rvalue reference)
                        */
                       void set_parameters(ArgumentVector&& parameters);

                       /**
                        * \brief Setter for member variable \ref NetReceiveBlock.parameters
                        */
                       void set_parameters(const ArgumentVector& parameters);
                    
    
                       /**
                        * \brief Setter for member variable \ref NetReceiveBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref NetReceiveBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NET_RECEIVE_BLOCK_HPP
#ifndef NMODL_AST_SOLVE_BLOCK_HPP
#define NMODL_AST_SOLVE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class SolveBlock : public Block {
  private:
    /// Name of the block to solve
      std::shared_ptr<Name> block_name;
    /// Name of the integration method
      std::shared_ptr<Name> method;
    /// Name of the integration method
      std::shared_ptr<Name> steadystate;
    /// Block to be executed on error
      std::shared_ptr<StatementBlock> ifsolerr;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit SolveBlock(Name* block_name, Name* method, Name* steadystate, StatementBlock* ifsolerr);
      explicit SolveBlock(const std::shared_ptr<Name>& block_name, const std::shared_ptr<Name>& method, const std::shared_ptr<Name>& steadystate, const std::shared_ptr<StatementBlock>& ifsolerr);
    SolveBlock(const SolveBlock& obj);


  virtual ~SolveBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::SolveBlock
   * \return true as object is of type ast::SolveBlock
   */
  bool is_solve_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   SolveBlock* clone() const override {
    return new SolveBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SOLVE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SOLVE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SolveBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "SolveBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "SOLVE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "SOLVE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SolveBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SolveBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref SolveBlock.block_name
                    */
                   const std::shared_ptr<Name>& get_block_name() const noexcept  {
                       return block_name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref SolveBlock.method
                    */
                   const std::shared_ptr<Name>& get_method() const noexcept  {
                       return method;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref SolveBlock.steadystate
                    */
                   const std::shared_ptr<Name>& get_steadystate() const noexcept  {
                       return steadystate;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref SolveBlock.ifsolerr
                    */
                   const std::shared_ptr<StatementBlock>& get_ifsolerr() const noexcept  {
                       return ifsolerr;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref SolveBlock.block_name (rvalue reference)
                        */
                       void set_block_name(std::shared_ptr<Name>&& block_name);

                       /**
                        * \brief Setter for member variable \ref SolveBlock.block_name
                        */
                       void set_block_name(const std::shared_ptr<Name>& block_name);
                    
    
                       /**
                        * \brief Setter for member variable \ref SolveBlock.method (rvalue reference)
                        */
                       void set_method(std::shared_ptr<Name>&& method);

                       /**
                        * \brief Setter for member variable \ref SolveBlock.method
                        */
                       void set_method(const std::shared_ptr<Name>& method);
                    
    
                       /**
                        * \brief Setter for member variable \ref SolveBlock.steadystate (rvalue reference)
                        */
                       void set_steadystate(std::shared_ptr<Name>&& steadystate);

                       /**
                        * \brief Setter for member variable \ref SolveBlock.steadystate
                        */
                       void set_steadystate(const std::shared_ptr<Name>& steadystate);
                    
    
                       /**
                        * \brief Setter for member variable \ref SolveBlock.ifsolerr (rvalue reference)
                        */
                       void set_ifsolerr(std::shared_ptr<StatementBlock>&& ifsolerr);

                       /**
                        * \brief Setter for member variable \ref SolveBlock.ifsolerr
                        */
                       void set_ifsolerr(const std::shared_ptr<StatementBlock>& ifsolerr);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SOLVE_BLOCK_HPP
#ifndef NMODL_AST_BREAKPOINT_BLOCK_HPP
#define NMODL_AST_BREAKPOINT_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `BREAKPOINT` block in NMODL
 *
 * The `BREAKPOINT` block is used to update current and conductance.
  * at each time step. Here is an example of `BEFORE` :
  * 
  * \code{.mod}
  *     BREAKPOINT {
  *         SOLVE states METHOD cnexp
  *         gna = gnabar*m*m*m*h
  *         ina = gna*(v - ena)
  *         gk = gkbar*n*n*n*n
  *         ik = gk*(v - ek)
  *         il = gl*(v - el)
  *     }
  * \endcode
  * 
  * \sa ast::DerivativeBlock ast::InitialBlock
  * 
*/
class BreakpointBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BreakpointBlock(StatementBlock* statement_block);
      explicit BreakpointBlock(const std::shared_ptr<StatementBlock>& statement_block);
    BreakpointBlock(const BreakpointBlock& obj);


  virtual ~BreakpointBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BreakpointBlock
   * \return true as object is of type ast::BreakpointBlock
   */
  bool is_breakpoint_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BreakpointBlock* clone() const override {
    return new BreakpointBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BREAKPOINT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BREAKPOINT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BreakpointBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BreakpointBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "BREAKPOINT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "BREAKPOINT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BreakpointBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BreakpointBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BreakpointBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref BreakpointBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref BreakpointBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BREAKPOINT_BLOCK_HPP
#ifndef NMODL_AST_TERMINAL_BLOCK_HPP
#define NMODL_AST_TERMINAL_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class TerminalBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit TerminalBlock(StatementBlock* statement_block);
      explicit TerminalBlock(const std::shared_ptr<StatementBlock>& statement_block);
    TerminalBlock(const TerminalBlock& obj);


  virtual ~TerminalBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::TerminalBlock
   * \return true as object is of type ast::TerminalBlock
   */
  bool is_terminal_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   TerminalBlock* clone() const override {
    return new TerminalBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::TERMINAL_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::TERMINAL_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "TerminalBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "TerminalBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "TERMINAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "TERMINAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<TerminalBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const TerminalBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref TerminalBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref TerminalBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref TerminalBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_TERMINAL_BLOCK_HPP
#ifndef NMODL_AST_BEFORE_BLOCK_HPP
#define NMODL_AST_BEFORE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `BEFORE` block in NMODL
 *
 * 
*/
class BeforeBlock : public Block {
  private:
    /// Block to be called before
      std::shared_ptr<BABlock> bablock;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BeforeBlock(BABlock* bablock);
      explicit BeforeBlock(const std::shared_ptr<BABlock>& bablock);
    BeforeBlock(const BeforeBlock& obj);


  virtual ~BeforeBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BeforeBlock
   * \return true as object is of type ast::BeforeBlock
   */
  bool is_before_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BeforeBlock* clone() const override {
    return new BeforeBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BEFORE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BEFORE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BeforeBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BeforeBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "BEFORE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "BEFORE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BeforeBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BeforeBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BeforeBlock.bablock
                    */
                   const std::shared_ptr<BABlock>& get_bablock() const noexcept  {
                       return bablock;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref BeforeBlock.bablock (rvalue reference)
                        */
                       void set_bablock(std::shared_ptr<BABlock>&& bablock);

                       /**
                        * \brief Setter for member variable \ref BeforeBlock.bablock
                        */
                       void set_bablock(const std::shared_ptr<BABlock>& bablock);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BEFORE_BLOCK_HPP
#ifndef NMODL_AST_AFTER_BLOCK_HPP
#define NMODL_AST_AFTER_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `AFTER` block in NMODL
 *
 * This represents a block to be executed before another block.
  * Here is an example of `BEFORE` :
  * 
  * \code{.mod}
  *     BEFORE STEP {
  *       if (mode==1) {
  *         if (ica<imax) {
  *           imax = ica
  *           timax = t
  *         }
  *       }
  *     }
  * \endcode
  * 
*/
class AfterBlock : public Block {
  private:
    /// Block to be called after
      std::shared_ptr<BABlock> bablock;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit AfterBlock(BABlock* bablock);
      explicit AfterBlock(const std::shared_ptr<BABlock>& bablock);
    AfterBlock(const AfterBlock& obj);


  virtual ~AfterBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::AfterBlock
   * \return true as object is of type ast::AfterBlock
   */
  bool is_after_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   AfterBlock* clone() const override {
    return new AfterBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::AFTER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::AFTER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AfterBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "AfterBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "AFTER "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "AFTER ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AfterBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AfterBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref AfterBlock.bablock
                    */
                   const std::shared_ptr<BABlock>& get_bablock() const noexcept  {
                       return bablock;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref AfterBlock.bablock (rvalue reference)
                        */
                       void set_bablock(std::shared_ptr<BABlock>&& bablock);

                       /**
                        * \brief Setter for member variable \ref AfterBlock.bablock
                        */
                       void set_bablock(const std::shared_ptr<BABlock>& bablock);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_AFTER_BLOCK_HPP
#ifndef NMODL_AST_BA_BLOCK_HPP
#define NMODL_AST_BA_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a block to be executed before or after another block
 *
 * This represents a block to be executed before or after another
  * block in NMODL. See ast::BeforeBlock and ast::AfterBlock for usage.
  * 
*/
class BABlock : public Block {
  private:
    /// Type of NMODL block
      std::shared_ptr<BABlockType> type;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BABlock(BABlockType* type, StatementBlock* statement_block);
      explicit BABlock(const std::shared_ptr<BABlockType>& type, const std::shared_ptr<StatementBlock>& statement_block);
    BABlock(const BABlock& obj);


  virtual ~BABlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BABlock
   * \return true as object is of type ast::BABlock
   */
  bool is_ba_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BABlock* clone() const override {
    return new BABlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BA_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BA_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BABlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BABlock";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BABlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BABlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BABlock.type
                    */
                   const std::shared_ptr<BABlockType>& get_type() const noexcept  {
                       return type;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref BABlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref BABlock.type (rvalue reference)
                        */
                       void set_type(std::shared_ptr<BABlockType>&& type);

                       /**
                        * \brief Setter for member variable \ref BABlock.type
                        */
                       void set_type(const std::shared_ptr<BABlockType>& type);
                    
    
                       /**
                        * \brief Setter for member variable \ref BABlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref BABlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BA_BLOCK_HPP
#ifndef NMODL_AST_FOR_NETCON_HPP
#define NMODL_AST_FOR_NETCON_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ForNetcon : public Block {
  private:
    /// Arguments to the for netcon block
      ArgumentVector parameters;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ForNetcon(ArgumentVector parameters, StatementBlock* statement_block);
      explicit ForNetcon(const ArgumentVector& parameters, const std::shared_ptr<StatementBlock>& statement_block);
    ForNetcon(const ForNetcon& obj);


  virtual ~ForNetcon() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ForNetcon
   * \return true as object is of type ast::ForNetcon
   */
  bool is_for_netcon () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ForNetcon* clone() const override {
    return new ForNetcon(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FOR_NETCON
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FOR_NETCON;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ForNetcon"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ForNetcon";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "FOR_NETCONS "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "FOR_NETCONS ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ForNetcon>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ForNetcon>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ForNetcon.parameters
                    */
                   const ArgumentVector& get_parameters() const noexcept  override {
                       return parameters;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ForNetcon.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref ForNetcon.parameters (rvalue reference)
                        */
                       void set_parameters(ArgumentVector&& parameters);

                       /**
                        * \brief Setter for member variable \ref ForNetcon.parameters
                        */
                       void set_parameters(const ArgumentVector& parameters);
                    
    
                       /**
                        * \brief Setter for member variable \ref ForNetcon.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ForNetcon.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FOR_NETCON_HPP
#ifndef NMODL_AST_KINETIC_BLOCK_HPP
#define NMODL_AST_KINETIC_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class KineticBlock : public Block {
  private:
    /// Name of the kinetic block
      std::shared_ptr<Name> name;
    /// Solve for specification (TODO)
      NameVector solvefor;
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit KineticBlock(Name* name, NameVector solvefor, StatementBlock* statement_block);
      explicit KineticBlock(const std::shared_ptr<Name>& name, const NameVector& solvefor, const std::shared_ptr<StatementBlock>& statement_block);
    KineticBlock(const KineticBlock& obj);


  virtual ~KineticBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::KineticBlock
   * \return true as object is of type ast::KineticBlock
   */
  bool is_kinetic_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   KineticBlock* clone() const override {
    return new KineticBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::KINETIC_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::KINETIC_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "KineticBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "KineticBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "KINETIC "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "KINETIC ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<KineticBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const KineticBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref KineticBlock.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref KineticBlock.solvefor
                    */
                   const NameVector& get_solvefor() const noexcept  {
                       return solvefor;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref KineticBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref KineticBlock.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref KineticBlock.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref KineticBlock.solvefor (rvalue reference)
                        */
                       void set_solvefor(NameVector&& solvefor);

                       /**
                        * \brief Setter for member variable \ref KineticBlock.solvefor
                        */
                       void set_solvefor(const NameVector& solvefor);
                    
    
                       /**
                        * \brief Setter for member variable \ref KineticBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref KineticBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_KINETIC_BLOCK_HPP
#ifndef NMODL_AST_MATCH_BLOCK_HPP
#define NMODL_AST_MATCH_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class MatchBlock : public Block {
  private:
    /// Vector of match statements
      MatchVector matchs;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit MatchBlock(MatchVector matchs);
    MatchBlock(const MatchBlock& obj);


  virtual ~MatchBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::MatchBlock
   * \return true as object is of type ast::MatchBlock
   */
  bool is_match_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   MatchBlock* clone() const override {
    return new MatchBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MATCH_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MATCH_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MatchBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "MatchBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "MATCH"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "MATCH";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MatchBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MatchBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref MatchBlock.matchs
                    */
                   const MatchVector& get_matchs() const noexcept  {
                       return matchs;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref MatchBlock.matchs (rvalue reference)
                        */
                       void set_matchs(MatchVector&& matchs);

                       /**
                        * \brief Setter for member variable \ref MatchBlock.matchs
                        */
                       void set_matchs(const MatchVector& matchs);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_MATCH_BLOCK_HPP
#ifndef NMODL_AST_UNIT_BLOCK_HPP
#define NMODL_AST_UNIT_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class UnitBlock : public Block {
  private:
    /// Vector of unit statements
      ExpressionVector definitions;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UnitBlock(ExpressionVector definitions);
    UnitBlock(const UnitBlock& obj);


  virtual ~UnitBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UnitBlock
   * \return true as object is of type ast::UnitBlock
   */
  bool is_unit_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UnitBlock* clone() const override {
    return new UnitBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UnitBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "UNITS "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "UNITS ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref UnitBlock.definitions
                    */
                   const ExpressionVector& get_definitions() const noexcept  {
                       return definitions;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref UnitBlock.definitions (rvalue reference)
                        */
                       void set_definitions(ExpressionVector&& definitions);

                       /**
                        * \brief Setter for member variable \ref UnitBlock.definitions
                        */
                       void set_definitions(const ExpressionVector& definitions);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNIT_BLOCK_HPP
#ifndef NMODL_AST_CONSTANT_BLOCK_HPP
#define NMODL_AST_CONSTANT_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent `CONSTANT` block in the mod file
 *
 * Here is an example of `CONSTANT` block in mod file:
  * 
  * \code{.mod}
  *     CONSTANT {
  *         q10 = 3
  * 
  *         cvm = 28.9 (mV)
  *         ckm = 6.2 (mV)
  *         ctm = 0.000505 (s)
  *     }
  * \endcode
  * 
*/
class ConstantBlock : public Block {
  private:
    /// Vector of constant statements
      ConstantStatementVector statements;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ConstantBlock(ConstantStatementVector statements);
    ConstantBlock(const ConstantBlock& obj);


  virtual ~ConstantBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ConstantBlock
   * \return true as object is of type ast::ConstantBlock
   */
  bool is_constant_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ConstantBlock* clone() const override {
    return new ConstantBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ConstantBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "CONSTANT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "CONSTANT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ConstantBlock.statements
                    */
                   const ConstantStatementVector& get_statements() const noexcept  {
                       return statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref ConstantBlock.statements (rvalue reference)
                        */
                       void set_statements(ConstantStatementVector&& statements);

                       /**
                        * \brief Setter for member variable \ref ConstantBlock.statements
                        */
                       void set_statements(const ConstantStatementVector& statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONSTANT_BLOCK_HPP
#ifndef NMODL_AST_NEURON_BLOCK_HPP
#define NMODL_AST_NEURON_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent `NEURON` block in the mod file
 *
 * The keyword `NEURON` introduces a special block which contains statements
  * that tell NMODL how to organize the variables for access at the NEURON user
  * level. Here is an example of `NEURON` block from `HH` channel:
  * 
  * \code{.mod}
  *     NEURON {
  *             SUFFIX hh
  *             USEION na READ ena WRITE ina
  *             USEION k READ ek WRITE ik
  *             NONSPECIFIC_CURRENT il
  *             RANGE gnabar, gkbar, gl, el, gna, gk
  *             RANGE minf, hinf, ninf, mtau, htau, ntau
  *             THREADSAFE
  *     }
  * \endcode
  * 
*/
class NeuronBlock : public Block {
  private:
    /// Block with statements vector
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NeuronBlock(StatementBlock* statement_block);
      explicit NeuronBlock(const std::shared_ptr<StatementBlock>& statement_block);
    NeuronBlock(const NeuronBlock& obj);


  virtual ~NeuronBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NeuronBlock
   * \return true as object is of type ast::NeuronBlock
   */
  bool is_neuron_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NeuronBlock* clone() const override {
    return new NeuronBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NEURON_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NEURON_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NeuronBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NeuronBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "NEURON "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "NEURON ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NeuronBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NeuronBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref NeuronBlock.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref NeuronBlock.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref NeuronBlock.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NEURON_BLOCK_HPP
#ifndef NMODL_AST_UNIT_HPP
#define NMODL_AST_UNIT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Unit : public Expression {
  private:
    /// TODO
      std::shared_ptr<String> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Unit(String* name);
      explicit Unit(const std::shared_ptr<String>& name);
    Unit(const Unit& obj);


  virtual ~Unit() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Unit
   * \return true as object is of type ast::Unit
   */
  bool is_unit () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Unit* clone() const override {
    return new Unit(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Unit"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Unit";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Unit>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Unit>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::String has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Unit.name
                    */
                   const std::shared_ptr<String>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Unit.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<String>&& name);

                       /**
                        * \brief Setter for member variable \ref Unit.name
                        */
                       void set_name(const std::shared_ptr<String>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNIT_HPP
#ifndef NMODL_AST_DOUBLE_UNIT_HPP
#define NMODL_AST_DOUBLE_UNIT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class DoubleUnit : public Expression {
  private:
    /// TODO
      std::shared_ptr<Double> value;
    /// TODO
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DoubleUnit(Double* value, Unit* unit);
      explicit DoubleUnit(const std::shared_ptr<Double>& value, const std::shared_ptr<Unit>& unit);
    DoubleUnit(const DoubleUnit& obj);


  virtual ~DoubleUnit() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DoubleUnit
   * \return true as object is of type ast::DoubleUnit
   */
  bool is_double_unit () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DoubleUnit* clone() const override {
    return new DoubleUnit(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DOUBLE_UNIT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DOUBLE_UNIT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DoubleUnit"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DoubleUnit";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DoubleUnit>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DoubleUnit>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref DoubleUnit.value
                    */
                   const std::shared_ptr<Double>& get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref DoubleUnit.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref DoubleUnit.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Double>&& value);

                       /**
                        * \brief Setter for member variable \ref DoubleUnit.value
                        */
                       void set_value(const std::shared_ptr<Double>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref DoubleUnit.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref DoubleUnit.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DOUBLE_UNIT_HPP
#ifndef NMODL_AST_LOCAL_VAR_HPP
#define NMODL_AST_LOCAL_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class LocalVar : public Expression {
  private:
    /// TODO
      std::shared_ptr<Identifier> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LocalVar(Identifier* name);
      explicit LocalVar(const std::shared_ptr<Identifier>& name);
    LocalVar(const LocalVar& obj);


  virtual ~LocalVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LocalVar
   * \return true as object is of type ast::LocalVar
   */
  bool is_local_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LocalVar* clone() const override {
    return new LocalVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LOCAL_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LOCAL_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LocalVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LocalVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LocalVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LocalVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref LocalVar.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LocalVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref LocalVar.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LOCAL_VAR_HPP
#ifndef NMODL_AST_LIMITS_HPP
#define NMODL_AST_LIMITS_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Limits : public Expression {
  private:
    /// TODO
      std::shared_ptr<Double> min;
    /// TODO
      std::shared_ptr<Double> max;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Limits(Double* min, Double* max);
      explicit Limits(const std::shared_ptr<Double>& min, const std::shared_ptr<Double>& max);
    Limits(const Limits& obj);


  virtual ~Limits() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Limits
   * \return true as object is of type ast::Limits
   */
  bool is_limits () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Limits* clone() const override {
    return new Limits(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LIMITS
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LIMITS;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Limits"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Limits";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Limits>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Limits>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Limits.min
                    */
                   const std::shared_ptr<Double>& get_min() const noexcept  {
                       return min;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Limits.max
                    */
                   const std::shared_ptr<Double>& get_max() const noexcept  {
                       return max;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Limits.min (rvalue reference)
                        */
                       void set_min(std::shared_ptr<Double>&& min);

                       /**
                        * \brief Setter for member variable \ref Limits.min
                        */
                       void set_min(const std::shared_ptr<Double>& min);
                    
    
                       /**
                        * \brief Setter for member variable \ref Limits.max (rvalue reference)
                        */
                       void set_max(std::shared_ptr<Double>&& max);

                       /**
                        * \brief Setter for member variable \ref Limits.max
                        */
                       void set_max(const std::shared_ptr<Double>& max);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LIMITS_HPP
#ifndef NMODL_AST_NUMBER_RANGE_HPP
#define NMODL_AST_NUMBER_RANGE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class NumberRange : public Expression {
  private:
    /// TODO
      std::shared_ptr<Number> min;
    /// TODO
      std::shared_ptr<Number> max;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NumberRange(Number* min, Number* max);
      explicit NumberRange(const std::shared_ptr<Number>& min, const std::shared_ptr<Number>& max);
    NumberRange(const NumberRange& obj);


  virtual ~NumberRange() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NumberRange
   * \return true as object is of type ast::NumberRange
   */
  bool is_number_range () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NumberRange* clone() const override {
    return new NumberRange(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NUMBER_RANGE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NUMBER_RANGE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NumberRange"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NumberRange";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NumberRange>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NumberRange>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref NumberRange.min
                    */
                   const std::shared_ptr<Number>& get_min() const noexcept  {
                       return min;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref NumberRange.max
                    */
                   const std::shared_ptr<Number>& get_max() const noexcept  {
                       return max;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref NumberRange.min (rvalue reference)
                        */
                       void set_min(std::shared_ptr<Number>&& min);

                       /**
                        * \brief Setter for member variable \ref NumberRange.min
                        */
                       void set_min(const std::shared_ptr<Number>& min);
                    
    
                       /**
                        * \brief Setter for member variable \ref NumberRange.max (rvalue reference)
                        */
                       void set_max(std::shared_ptr<Number>&& max);

                       /**
                        * \brief Setter for member variable \ref NumberRange.max
                        */
                       void set_max(const std::shared_ptr<Number>& max);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NUMBER_RANGE_HPP
#ifndef NMODL_AST_PLOT_VAR_HPP
#define NMODL_AST_PLOT_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PlotVar : public Expression {
  private:
    /// TODO
      std::shared_ptr<Identifier> name;
    /// TODO
      std::shared_ptr<Integer> index;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PlotVar(Identifier* name, Integer* index);
      explicit PlotVar(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Integer>& index);
    PlotVar(const PlotVar& obj);


  virtual ~PlotVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PlotVar
   * \return true as object is of type ast::PlotVar
   */
  bool is_plot_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PlotVar* clone() const override {
    return new PlotVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PlotVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref PlotVar.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PlotVar.index
                    */
                   const std::shared_ptr<Integer>& get_index() const noexcept  {
                       return index;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PlotVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref PlotVar.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref PlotVar.index (rvalue reference)
                        */
                       void set_index(std::shared_ptr<Integer>&& index);

                       /**
                        * \brief Setter for member variable \ref PlotVar.index
                        */
                       void set_index(const std::shared_ptr<Integer>& index);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PLOT_VAR_HPP
#ifndef NMODL_AST_CONSTANT_VAR_HPP
#define NMODL_AST_CONSTANT_VAR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a variable in the ast::ConstantBlock
 *
 * 
*/
class ConstantVar : public Expression {
  private:
    /// Name of the variable
      std::shared_ptr<Name> name;
    /// Value of the constant
      std::shared_ptr<Number> value;
    /// Unit for the variable
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ConstantVar(Name* name, Number* value, Unit* unit);
      explicit ConstantVar(const std::shared_ptr<Name>& name, const std::shared_ptr<Number>& value, const std::shared_ptr<Unit>& unit);
    ConstantVar(const ConstantVar& obj);


  virtual ~ConstantVar() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ConstantVar
   * \return true as object is of type ast::ConstantVar
   */
  bool is_constant_var () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ConstantVar* clone() const override {
    return new ConstantVar(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_VAR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_VAR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantVar"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ConstantVar";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantVar>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantVar>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ConstantVar.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ConstantVar.value
                    */
                   const std::shared_ptr<Number>& get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ConstantVar.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ConstantVar.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ConstantVar.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref ConstantVar.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Number>&& value);

                       /**
                        * \brief Setter for member variable \ref ConstantVar.value
                        */
                       void set_value(const std::shared_ptr<Number>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref ConstantVar.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref ConstantVar.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONSTANT_VAR_HPP
#ifndef NMODL_AST_BINARY_OPERATOR_HPP
#define NMODL_AST_BINARY_OPERATOR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Operator used in ast::BinaryExpression
 *
 * 
*/
class BinaryOperator : public Expression {
  private:
    /// Operator
      BinaryOp value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BinaryOperator(BinaryOp value);
    BinaryOperator(const BinaryOperator& obj);

    BinaryOperator() = default;

  virtual ~BinaryOperator() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BinaryOperator
   * \return true as object is of type ast::BinaryOperator
   */
  bool is_binary_operator () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BinaryOperator* clone() const override {
    return new BinaryOperator(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BINARY_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BINARY_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BinaryOperator"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BinaryOperator";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BinaryOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BinaryOperator>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BinaryOperator.value
                    */
                   BinaryOp get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BinaryOperator.value
                        */
                       void set_value(BinaryOp value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return BinaryOpNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BINARY_OPERATOR_HPP
#ifndef NMODL_AST_UNARY_OPERATOR_HPP
#define NMODL_AST_UNARY_OPERATOR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class UnaryOperator : public Expression {
  private:
    /// TODO
      UnaryOp value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UnaryOperator(UnaryOp value);
    UnaryOperator(const UnaryOperator& obj);

    UnaryOperator() = default;

  virtual ~UnaryOperator() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UnaryOperator
   * \return true as object is of type ast::UnaryOperator
   */
  bool is_unary_operator () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UnaryOperator* clone() const override {
    return new UnaryOperator(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNARY_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNARY_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnaryOperator"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UnaryOperator";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnaryOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnaryOperator>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref UnaryOperator.value
                    */
                   UnaryOp get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref UnaryOperator.value
                        */
                       void set_value(UnaryOp value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return UnaryOpNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNARY_OPERATOR_HPP
#ifndef NMODL_AST_REACTION_OPERATOR_HPP
#define NMODL_AST_REACTION_OPERATOR_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ReactionOperator : public Expression {
  private:
    /// TODO
      ReactionOp value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ReactionOperator(ReactionOp value);
    ReactionOperator(const ReactionOperator& obj);

    ReactionOperator() = default;

  virtual ~ReactionOperator() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ReactionOperator
   * \return true as object is of type ast::ReactionOperator
   */
  bool is_reaction_operator () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ReactionOperator* clone() const override {
    return new ReactionOperator(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACTION_OPERATOR
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACTION_OPERATOR;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactionOperator"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ReactionOperator";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactionOperator>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactionOperator>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionOperator.value
                    */
                   ReactionOp get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ReactionOperator.value
                        */
                       void set_value(ReactionOp value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return ReactionOpNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_REACTION_OPERATOR_HPP
#ifndef NMODL_AST_PAREN_EXPRESSION_HPP
#define NMODL_AST_PAREN_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ParenExpression : public Expression {
  private:
    /// TODO
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ParenExpression(Expression* expression);
      explicit ParenExpression(const std::shared_ptr<Expression>& expression);
    ParenExpression(const ParenExpression& obj);


  virtual ~ParenExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ParenExpression
   * \return true as object is of type ast::ParenExpression
   */
  bool is_paren_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ParenExpression* clone() const override {
    return new ParenExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PAREN_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PAREN_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParenExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ParenExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParenExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParenExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ParenExpression.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ParenExpression.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref ParenExpression.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PAREN_EXPRESSION_HPP
#ifndef NMODL_AST_BINARY_EXPRESSION_HPP
#define NMODL_AST_BINARY_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents binary expression in the NMODL
 *
 * Any binary expression in the mod file is represented by this node type.
  * For example, in below example, there are three binary expressions :
  * 
  * \code{.mod}
  *     BREAKPOINT {
  *         SOLVE states METHOD cnexp
  *         ina = gna*(v - ena)
  *     }
  * \endcode
  * 
  * Note that the statement itself is stored in another type ast::ExpressionStatement.
  * 
  * \sa ast::ExpressionStatement
  * 
*/
class BinaryExpression : public Expression {
  private:
    /// LHS of the binary expression
      std::shared_ptr<Expression> lhs;
    /// Operator
      BinaryOperator op;
    /// RHS of the binary expression
      std::shared_ptr<Expression> rhs;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BinaryExpression(Expression* lhs, const BinaryOperator& op, Expression* rhs);
      explicit BinaryExpression(const std::shared_ptr<Expression>& lhs, const BinaryOperator& op, const std::shared_ptr<Expression>& rhs);
    BinaryExpression(const BinaryExpression& obj);


  virtual ~BinaryExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BinaryExpression
   * \return true as object is of type ast::BinaryExpression
   */
  bool is_binary_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BinaryExpression* clone() const override {
    return new BinaryExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BINARY_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BINARY_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BinaryExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BinaryExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BinaryExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BinaryExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BinaryExpression.lhs
                    */
                   const std::shared_ptr<Expression>& get_lhs() const noexcept  {
                       return lhs;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref BinaryExpression.op
                    */
                   const BinaryOperator& get_op() const noexcept  {
                       return op;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref BinaryExpression.rhs
                    */
                   const std::shared_ptr<Expression>& get_rhs() const noexcept  {
                       return rhs;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BinaryExpression.lhs (rvalue reference)
                        */
                       void set_lhs(std::shared_ptr<Expression>&& lhs);

                       /**
                        * \brief Setter for member variable \ref BinaryExpression.lhs
                        */
                       void set_lhs(const std::shared_ptr<Expression>& lhs);
                    
    
                       /**
                        * \brief Setter for member variable \ref BinaryExpression.op (rvalue reference)
                        */
                       void set_op(BinaryOperator&& op);

                       /**
                        * \brief Setter for member variable \ref BinaryExpression.op
                        */
                       void set_op(const BinaryOperator& op);
                    
    
                       /**
                        * \brief Setter for member variable \ref BinaryExpression.rhs (rvalue reference)
                        */
                       void set_rhs(std::shared_ptr<Expression>&& rhs);

                       /**
                        * \brief Setter for member variable \ref BinaryExpression.rhs
                        */
                       void set_rhs(const std::shared_ptr<Expression>& rhs);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BINARY_EXPRESSION_HPP
#ifndef NMODL_AST_DIFF_EQ_EXPRESSION_HPP
#define NMODL_AST_DIFF_EQ_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents differential equation in DERIVATIVE block
 *
 * 
*/
class DiffEqExpression : public Expression {
  private:
    /// Differential Expression
      std::shared_ptr<BinaryExpression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DiffEqExpression(BinaryExpression* expression);
      explicit DiffEqExpression(const std::shared_ptr<BinaryExpression>& expression);
    DiffEqExpression(const DiffEqExpression& obj);


  virtual ~DiffEqExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DiffEqExpression
   * \return true as object is of type ast::DiffEqExpression
   */
  bool is_diff_eq_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DiffEqExpression* clone() const override {
    return new DiffEqExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DIFF_EQ_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DIFF_EQ_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DiffEqExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DiffEqExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DiffEqExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DiffEqExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref DiffEqExpression.expression
                    */
                   const std::shared_ptr<BinaryExpression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref DiffEqExpression.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<BinaryExpression>&& expression);

                       /**
                        * \brief Setter for member variable \ref DiffEqExpression.expression
                        */
                       void set_expression(const std::shared_ptr<BinaryExpression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DIFF_EQ_EXPRESSION_HPP
#ifndef NMODL_AST_UNARY_EXPRESSION_HPP
#define NMODL_AST_UNARY_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class UnaryExpression : public Expression {
  private:
    /// TODO
      UnaryOperator op;
    /// TODO
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UnaryExpression(const UnaryOperator& op, Expression* expression);
      explicit UnaryExpression(const UnaryOperator& op, const std::shared_ptr<Expression>& expression);
    UnaryExpression(const UnaryExpression& obj);


  virtual ~UnaryExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UnaryExpression
   * \return true as object is of type ast::UnaryExpression
   */
  bool is_unary_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UnaryExpression* clone() const override {
    return new UnaryExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNARY_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNARY_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnaryExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UnaryExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnaryExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnaryExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref UnaryExpression.op
                    */
                   const UnaryOperator& get_op() const noexcept  {
                       return op;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref UnaryExpression.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref UnaryExpression.op (rvalue reference)
                        */
                       void set_op(UnaryOperator&& op);

                       /**
                        * \brief Setter for member variable \ref UnaryExpression.op
                        */
                       void set_op(const UnaryOperator& op);
                    
    
                       /**
                        * \brief Setter for member variable \ref UnaryExpression.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref UnaryExpression.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNARY_EXPRESSION_HPP
#ifndef NMODL_AST_NON_LIN_EQUATION_HPP
#define NMODL_AST_NON_LIN_EQUATION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class NonLinEquation : public Expression {
  private:
    /// TODO
      std::shared_ptr<Expression> lhs;
    /// TODO
      std::shared_ptr<Expression> rhs;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NonLinEquation(Expression* lhs, Expression* rhs);
      explicit NonLinEquation(const std::shared_ptr<Expression>& lhs, const std::shared_ptr<Expression>& rhs);
    NonLinEquation(const NonLinEquation& obj);


  virtual ~NonLinEquation() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NonLinEquation
   * \return true as object is of type ast::NonLinEquation
   */
  bool is_non_lin_equation () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NonLinEquation* clone() const override {
    return new NonLinEquation(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NON_LIN_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NON_LIN_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NonLinEquation"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NonLinEquation";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "~ "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "~ ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NonLinEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NonLinEquation>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref NonLinEquation.lhs
                    */
                   const std::shared_ptr<Expression>& get_lhs() const noexcept  {
                       return lhs;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref NonLinEquation.rhs
                    */
                   const std::shared_ptr<Expression>& get_rhs() const noexcept  {
                       return rhs;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref NonLinEquation.lhs (rvalue reference)
                        */
                       void set_lhs(std::shared_ptr<Expression>&& lhs);

                       /**
                        * \brief Setter for member variable \ref NonLinEquation.lhs
                        */
                       void set_lhs(const std::shared_ptr<Expression>& lhs);
                    
    
                       /**
                        * \brief Setter for member variable \ref NonLinEquation.rhs (rvalue reference)
                        */
                       void set_rhs(std::shared_ptr<Expression>&& rhs);

                       /**
                        * \brief Setter for member variable \ref NonLinEquation.rhs
                        */
                       void set_rhs(const std::shared_ptr<Expression>& rhs);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NON_LIN_EQUATION_HPP
#ifndef NMODL_AST_LIN_EQUATION_HPP
#define NMODL_AST_LIN_EQUATION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class LinEquation : public Expression {
  private:
    /// TODO
      std::shared_ptr<Expression> left_linxpression;
    /// TODO
      std::shared_ptr<Expression> linxpression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LinEquation(Expression* left_linxpression, Expression* linxpression);
      explicit LinEquation(const std::shared_ptr<Expression>& left_linxpression, const std::shared_ptr<Expression>& linxpression);
    LinEquation(const LinEquation& obj);


  virtual ~LinEquation() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LinEquation
   * \return true as object is of type ast::LinEquation
   */
  bool is_lin_equation () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LinEquation* clone() const override {
    return new LinEquation(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LIN_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LIN_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LinEquation"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LinEquation";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "~ "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "~ ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LinEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LinEquation>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref LinEquation.left_linxpression
                    */
                   const std::shared_ptr<Expression>& get_left_linxpression() const noexcept  {
                       return left_linxpression;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LinEquation.linxpression
                    */
                   const std::shared_ptr<Expression>& get_linxpression() const noexcept  {
                       return linxpression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LinEquation.left_linxpression (rvalue reference)
                        */
                       void set_left_linxpression(std::shared_ptr<Expression>&& left_linxpression);

                       /**
                        * \brief Setter for member variable \ref LinEquation.left_linxpression
                        */
                       void set_left_linxpression(const std::shared_ptr<Expression>& left_linxpression);
                    
    
                       /**
                        * \brief Setter for member variable \ref LinEquation.linxpression (rvalue reference)
                        */
                       void set_linxpression(std::shared_ptr<Expression>&& linxpression);

                       /**
                        * \brief Setter for member variable \ref LinEquation.linxpression
                        */
                       void set_linxpression(const std::shared_ptr<Expression>& linxpression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LIN_EQUATION_HPP
#ifndef NMODL_AST_FUNCTION_CALL_HPP
#define NMODL_AST_FUNCTION_CALL_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FunctionCall : public Expression {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      ExpressionVector arguments;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FunctionCall(Name* name, ExpressionVector arguments);
      explicit FunctionCall(const std::shared_ptr<Name>& name, const ExpressionVector& arguments);
    FunctionCall(const FunctionCall& obj);


  virtual ~FunctionCall() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FunctionCall
   * \return true as object is of type ast::FunctionCall
   */
  bool is_function_call () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FunctionCall* clone() const override {
    return new FunctionCall(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FUNCTION_CALL
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FUNCTION_CALL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FunctionCall"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FunctionCall";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FunctionCall>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FunctionCall>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref FunctionCall.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FunctionCall.arguments
                    */
                   const ExpressionVector& get_arguments() const noexcept  {
                       return arguments;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref FunctionCall.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref FunctionCall.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref FunctionCall.arguments (rvalue reference)
                        */
                       void set_arguments(ExpressionVector&& arguments);

                       /**
                        * \brief Setter for member variable \ref FunctionCall.arguments
                        */
                       void set_arguments(const ExpressionVector& arguments);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FUNCTION_CALL_HPP
#ifndef NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP
#define NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FirstLastTypeIndex : public Expression {
  private:
    /// TODO
      FirstLastType value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FirstLastTypeIndex(FirstLastType value);
    FirstLastTypeIndex(const FirstLastTypeIndex& obj);


  virtual ~FirstLastTypeIndex() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FirstLastTypeIndex
   * \return true as object is of type ast::FirstLastTypeIndex
   */
  bool is_first_last_type_index () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FirstLastTypeIndex* clone() const override {
    return new FirstLastTypeIndex(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FIRST_LAST_TYPE_INDEX
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FIRST_LAST_TYPE_INDEX;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FirstLastTypeIndex"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FirstLastTypeIndex";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FirstLastTypeIndex>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FirstLastTypeIndex>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref FirstLastTypeIndex.value
                    */
                   FirstLastType get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref FirstLastTypeIndex.value
                        */
                       void set_value(FirstLastType value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return FirstLastTypeNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FIRST_LAST_TYPE_INDEX_HPP
#ifndef NMODL_AST_WATCH_HPP
#define NMODL_AST_WATCH_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Watch : public Expression {
  private:
    /// TODO
      std::shared_ptr<Expression> expression;
    /// TODO
      std::shared_ptr<Expression> value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Watch(Expression* expression, Expression* value);
      explicit Watch(const std::shared_ptr<Expression>& expression, const std::shared_ptr<Expression>& value);
    Watch(const Watch& obj);


  virtual ~Watch() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Watch
   * \return true as object is of type ast::Watch
   */
  bool is_watch () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Watch* clone() const override {
    return new Watch(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WATCH
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WATCH;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Watch"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Watch";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Watch>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Watch>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Watch.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Watch.value
                    */
                   const std::shared_ptr<Expression>& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Watch.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref Watch.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    
    
                       /**
                        * \brief Setter for member variable \ref Watch.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Expression>&& value);

                       /**
                        * \brief Setter for member variable \ref Watch.value
                        */
                       void set_value(const std::shared_ptr<Expression>& value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_WATCH_HPP
#ifndef NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP
#define NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class QueueExpressionType : public Expression {
  private:
    /// TODO
      QueueType value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit QueueExpressionType(QueueType value);
    QueueExpressionType(const QueueExpressionType& obj);


  virtual ~QueueExpressionType() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::QueueExpressionType
   * \return true as object is of type ast::QueueExpressionType
   */
  bool is_queue_expression_type () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   QueueExpressionType* clone() const override {
    return new QueueExpressionType(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::QUEUE_EXPRESSION_TYPE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::QUEUE_EXPRESSION_TYPE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "QueueExpressionType"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "QueueExpressionType";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<QueueExpressionType>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const QueueExpressionType>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref QueueExpressionType.value
                    */
                   QueueType get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref QueueExpressionType.value
                        */
                       void set_value(QueueType value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return QueueTypeNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_QUEUE_EXPRESSION_TYPE_HPP
#ifndef NMODL_AST_MATCH_HPP
#define NMODL_AST_MATCH_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Match : public Expression {
  private:
    /// TODO
      std::shared_ptr<Identifier> name;
    /// TODO
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Match(Identifier* name, Expression* expression);
      explicit Match(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Expression>& expression);
    Match(const Match& obj);


  virtual ~Match() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Match
   * \return true as object is of type ast::Match
   */
  bool is_match () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Match* clone() const override {
    return new Match(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MATCH
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MATCH;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Match"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Match";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Match>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Match>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Match.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Match.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Match.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref Match.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Match.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref Match.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_MATCH_HPP
#ifndef NMODL_AST_BA_BLOCK_TYPE_HPP
#define NMODL_AST_BA_BLOCK_TYPE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Type to represent different block types for before/after block
 *
 * Different NMODL blocks can be used with ast::BeforeBlock and ast::AfterBlock.
  * This type is used to represent such block types.
  * 
  * \sa ast::BeforeBlock as::AfterBlock
  * 
*/
class BABlockType : public Expression {
  private:
    /// block type
      BAType value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BABlockType(BAType value);
    BABlockType(const BABlockType& obj);


  virtual ~BABlockType() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BABlockType
   * \return true as object is of type ast::BABlockType
   */
  bool is_ba_block_type () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BABlockType* clone() const override {
    return new BABlockType(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BA_BLOCK_TYPE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BA_BLOCK_TYPE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BABlockType"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BABlockType";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BABlockType>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BABlockType>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BABlockType.value
                    */
                   BAType get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BABlockType.value
                        */
                       void set_value(BAType value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return BATypeNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BA_BLOCK_TYPE_HPP
#ifndef NMODL_AST_UNIT_DEF_HPP
#define NMODL_AST_UNIT_DEF_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class UnitDef : public Expression {
  private:
    /// TODO
      std::shared_ptr<Unit> unit1;
    /// TODO
      std::shared_ptr<Unit> unit2;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UnitDef(Unit* unit1, Unit* unit2);
      explicit UnitDef(const std::shared_ptr<Unit>& unit1, const std::shared_ptr<Unit>& unit2);
    UnitDef(const UnitDef& obj);


  virtual ~UnitDef() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UnitDef
   * \return true as object is of type ast::UnitDef
   */
  bool is_unit_def () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UnitDef* clone() const override {
    return new UnitDef(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_DEF
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_DEF;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitDef"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UnitDef";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitDef>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitDef>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Unit has unit1 designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref UnitDef.unit1
                    */
                   const std::shared_ptr<Unit>& get_unit1() const noexcept  {
                       return unit1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref UnitDef.unit2
                    */
                   const std::shared_ptr<Unit>& get_unit2() const noexcept  {
                       return unit2;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref UnitDef.unit1 (rvalue reference)
                        */
                       void set_unit1(std::shared_ptr<Unit>&& unit1);

                       /**
                        * \brief Setter for member variable \ref UnitDef.unit1
                        */
                       void set_unit1(const std::shared_ptr<Unit>& unit1);
                    
    
                       /**
                        * \brief Setter for member variable \ref UnitDef.unit2 (rvalue reference)
                        */
                       void set_unit2(std::shared_ptr<Unit>&& unit2);

                       /**
                        * \brief Setter for member variable \ref UnitDef.unit2
                        */
                       void set_unit2(const std::shared_ptr<Unit>& unit2);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNIT_DEF_HPP
#ifndef NMODL_AST_FACTOR_DEF_HPP
#define NMODL_AST_FACTOR_DEF_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FactorDef : public Expression {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<Double> value;
    /// TODO
      std::shared_ptr<Unit> unit1;
    /// Todo: Michael : rename variable gt as well
      std::shared_ptr<Boolean> gt;
    /// TODO
      std::shared_ptr<Unit> unit2;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FactorDef(Name* name, Double* value, Unit* unit1, Boolean* gt, Unit* unit2);
      explicit FactorDef(const std::shared_ptr<Name>& name, const std::shared_ptr<Double>& value, const std::shared_ptr<Unit>& unit1, const std::shared_ptr<Boolean>& gt, const std::shared_ptr<Unit>& unit2);
    FactorDef(const FactorDef& obj);

    FactorDef() = default;

  virtual ~FactorDef() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FactorDef
   * \return true as object is of type ast::FactorDef
   */
  bool is_factor_def () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FactorDef* clone() const override {
    return new FactorDef(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FACTOR_DEF
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FACTOR_DEF;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FactorDef"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FactorDef";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FactorDef>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FactorDef>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref FactorDef.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FactorDef.value
                    */
                   const std::shared_ptr<Double>& get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FactorDef.unit1
                    */
                   const std::shared_ptr<Unit>& get_unit1() const noexcept  {
                       return unit1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FactorDef.gt
                    */
                   const std::shared_ptr<Boolean>& get_gt() const noexcept  {
                       return gt;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FactorDef.unit2
                    */
                   const std::shared_ptr<Unit>& get_unit2() const noexcept  {
                       return unit2;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref FactorDef.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref FactorDef.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref FactorDef.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Double>&& value);

                       /**
                        * \brief Setter for member variable \ref FactorDef.value
                        */
                       void set_value(const std::shared_ptr<Double>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref FactorDef.unit1 (rvalue reference)
                        */
                       void set_unit1(std::shared_ptr<Unit>&& unit1);

                       /**
                        * \brief Setter for member variable \ref FactorDef.unit1
                        */
                       void set_unit1(const std::shared_ptr<Unit>& unit1);
                    
    
                       /**
                        * \brief Setter for member variable \ref FactorDef.gt (rvalue reference)
                        */
                       void set_gt(std::shared_ptr<Boolean>&& gt);

                       /**
                        * \brief Setter for member variable \ref FactorDef.gt
                        */
                       void set_gt(const std::shared_ptr<Boolean>& gt);
                    
    
                       /**
                        * \brief Setter for member variable \ref FactorDef.unit2 (rvalue reference)
                        */
                       void set_unit2(std::shared_ptr<Unit>&& unit2);

                       /**
                        * \brief Setter for member variable \ref FactorDef.unit2
                        */
                       void set_unit2(const std::shared_ptr<Unit>& unit2);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FACTOR_DEF_HPP
#ifndef NMODL_AST_VALENCE_HPP
#define NMODL_AST_VALENCE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Valence : public Expression {
  private:
    /// TODO
      std::shared_ptr<Name> type;
    /// TODO
      std::shared_ptr<Double> value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Valence(Name* type, Double* value);
      explicit Valence(const std::shared_ptr<Name>& type, const std::shared_ptr<Double>& value);
    Valence(const Valence& obj);


  virtual ~Valence() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Valence
   * \return true as object is of type ast::Valence
   */
  bool is_valence () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Valence* clone() const override {
    return new Valence(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VALENCE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VALENCE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Valence"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Valence";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Valence>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Valence>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Valence.type
                    */
                   const std::shared_ptr<Name>& get_type() const noexcept  {
                       return type;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Valence.value
                    */
                   const std::shared_ptr<Double>& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Valence.type (rvalue reference)
                        */
                       void set_type(std::shared_ptr<Name>&& type);

                       /**
                        * \brief Setter for member variable \ref Valence.type
                        */
                       void set_type(const std::shared_ptr<Name>& type);
                    
    
                       /**
                        * \brief Setter for member variable \ref Valence.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Double>&& value);

                       /**
                        * \brief Setter for member variable \ref Valence.value
                        */
                       void set_value(const std::shared_ptr<Double>& value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_VALENCE_HPP
#ifndef NMODL_AST_UNIT_STATE_HPP
#define NMODL_AST_UNIT_STATE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class UnitState : public Statement {
  private:
    /// TODO
      UnitStateType value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UnitState(UnitStateType value);
    UnitState(const UnitState& obj);


  virtual ~UnitState() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UnitState
   * \return true as object is of type ast::UnitState
   */
  bool is_unit_state () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UnitState* clone() const override {
    return new UnitState(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UNIT_STATE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UNIT_STATE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UnitState"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UnitState";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UnitState>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UnitState>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref UnitState.value
                    */
                   UnitStateType get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref UnitState.value
                        */
                       void set_value(UnitStateType value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}


      /**
       * \brief Return enum value in string form
       *
       * Enum variables (e.g. ast::BinaryOp, ast::UnitStateType) have
       * string representation when they are converted from AST back to
       * NMODL. This method is used to return corresponding string representation.
       */
      std::string eval() const {
        return UnitStateTypeNames[value];
      }


  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UNIT_STATE_HPP
#ifndef NMODL_AST_LOCAL_LIST_STATEMENT_HPP
#define NMODL_AST_LOCAL_LIST_STATEMENT_HPP
#define NMODL_AST_LOCAL_LIST_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class LocalListStatement : public Statement {
  private:
    /// TODO
      LocalVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LocalListStatement(LocalVarVector variables);
    LocalListStatement(const LocalListStatement& obj);


  virtual ~LocalListStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LocalListStatement
   * \return true as object is of type ast::LocalListStatement
   */
  bool is_local_list_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LocalListStatement* clone() const override {
    return new LocalListStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LOCAL_LIST_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LOCAL_LIST_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LocalListStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LocalListStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "LOCAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "LOCAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LocalListStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LocalListStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    
/**
 * \brief Add member to variables by raw pointer
 */
void emplace_back_local_var(LocalVar *n);

/**
 * \brief Add member to variables by shared_ptr
 */
void emplace_back_local_var(std::shared_ptr<LocalVar> n);

/**
 * \brief Erase member to variables
 */
LocalVarVector::const_iterator erase_local_var(LocalVarVector::const_iterator first);

/**
 * \brief Erase members to variables
 */
LocalVarVector::const_iterator erase_local_var(LocalVarVector::const_iterator first, LocalVarVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to variables
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_local_var(std::unordered_set<LocalVar*>& to_be_erased);

/**
 * \brief Insert member to variables
 */
LocalVarVector::const_iterator insert_local_var(LocalVarVector::const_iterator position, const std::shared_ptr<LocalVar>& n);

/**
 * \brief Insert members to variables
 */
template <class NodeType, class InputIterator>
void insert_local_var(LocalVarVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to variables
 */
void reset_local_var(LocalVarVector::const_iterator position, LocalVar* n);

/**
 * \brief Reset member to variables
 */
void reset_local_var(LocalVarVector::const_iterator position, std::shared_ptr<LocalVar> n);


    

    
                   /**
                    * \brief Getter for member variable \ref LocalListStatement.variables
                    */
                   const LocalVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LocalListStatement.variables (rvalue reference)
                        */
                       void set_variables(LocalVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref LocalListStatement.variables
                        */
                       void set_variables(const LocalVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LOCAL_LIST_STATEMENT_HPP
#ifndef NMODL_AST_MODEL_HPP
#define NMODL_AST_MODEL_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Model : public Statement {
  private:
    /// TODO
      std::shared_ptr<String> title;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Model(String* title);
      explicit Model(const std::shared_ptr<String>& title);
    Model(const Model& obj);


  virtual ~Model() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Model
   * \return true as object is of type ast::Model
   */
  bool is_model () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Model* clone() const override {
    return new Model(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MODEL
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MODEL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Model"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Model";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "TITLE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "TITLE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Model>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Model>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Model.title
                    */
                   const std::shared_ptr<String>& get_title() const noexcept  {
                       return title;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Model.title (rvalue reference)
                        */
                       void set_title(std::shared_ptr<String>&& title);

                       /**
                        * \brief Setter for member variable \ref Model.title
                        */
                       void set_title(const std::shared_ptr<String>& title);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_MODEL_HPP
#ifndef NMODL_AST_DEFINE_HPP
#define NMODL_AST_DEFINE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a `DEFINE` statement in NMODL
 *
 * 
*/
class Define : public Statement {
  private:
    /// Name of the macro
      std::shared_ptr<Name> name;
    /// Value of the macro
      std::shared_ptr<Integer> value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Define(Name* name, Integer* value);
      explicit Define(const std::shared_ptr<Name>& name, const std::shared_ptr<Integer>& value);
    Define(const Define& obj);


  virtual ~Define() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Define
   * \return true as object is of type ast::Define
   */
  bool is_define () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Define* clone() const override {
    return new Define(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DEFINE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DEFINE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Define"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Define";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "DEFINE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "DEFINE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Define>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Define>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Define.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Define.value
                    */
                   const std::shared_ptr<Integer>& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Define.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref Define.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Define.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Integer>&& value);

                       /**
                        * \brief Setter for member variable \ref Define.value
                        */
                       void set_value(const std::shared_ptr<Integer>& value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DEFINE_HPP
#ifndef NMODL_AST_INCLUDE_HPP
#define NMODL_AST_INCLUDE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents an `INCLUDE` statement in NMODL
 *
 * 
*/
class Include : public Statement {
  private:
    /// path to the file to include
      std::shared_ptr<String> filename;
    /// AST of the included file
      NodeVector blocks;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Include(String* filename, NodeVector blocks);
      explicit Include(const std::shared_ptr<String>& filename, const NodeVector& blocks);
    Include(const Include& obj);


  virtual ~Include() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Include
   * \return true as object is of type ast::Include
   */
  bool is_include () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Include* clone() const override {
    return new Include(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INCLUDE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INCLUDE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Include"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Include";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "INCLUDE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "INCLUDE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Include>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Include>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Include.filename
                    */
                   const std::shared_ptr<String>& get_filename() const noexcept  {
                       return filename;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Include.blocks
                    */
                   const NodeVector& get_blocks() const noexcept  {
                       return blocks;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Include.filename (rvalue reference)
                        */
                       void set_filename(std::shared_ptr<String>&& filename);

                       /**
                        * \brief Setter for member variable \ref Include.filename
                        */
                       void set_filename(const std::shared_ptr<String>& filename);
                    
    
                       /**
                        * \brief Setter for member variable \ref Include.blocks (rvalue reference)
                        */
                       void set_blocks(NodeVector&& blocks);

                       /**
                        * \brief Setter for member variable \ref Include.blocks
                        */
                       void set_blocks(const NodeVector& blocks);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INCLUDE_HPP
#ifndef NMODL_AST_PARAM_ASSIGN_HPP
#define NMODL_AST_PARAM_ASSIGN_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ParamAssign : public Statement {
  private:
    /// TODO
      std::shared_ptr<Identifier> name;
    /// TODO
      std::shared_ptr<Number> value;
    /// TODO
      std::shared_ptr<Unit> unit;
    /// TODO
      std::shared_ptr<Limits> limit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ParamAssign(Identifier* name, Number* value, Unit* unit, Limits* limit);
      explicit ParamAssign(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Number>& value, const std::shared_ptr<Unit>& unit, const std::shared_ptr<Limits>& limit);
    ParamAssign(const ParamAssign& obj);


  virtual ~ParamAssign() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ParamAssign
   * \return true as object is of type ast::ParamAssign
   */
  bool is_param_assign () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ParamAssign* clone() const override {
    return new ParamAssign(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARAM_ASSIGN
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARAM_ASSIGN;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ParamAssign"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ParamAssign";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ParamAssign>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ParamAssign>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref ParamAssign.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ParamAssign.value
                    */
                   const std::shared_ptr<Number>& get_value() const noexcept  {
                       return value;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ParamAssign.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ParamAssign.limit
                    */
                   const std::shared_ptr<Limits>& get_limit() const noexcept  {
                       return limit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ParamAssign.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref ParamAssign.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref ParamAssign.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Number>&& value);

                       /**
                        * \brief Setter for member variable \ref ParamAssign.value
                        */
                       void set_value(const std::shared_ptr<Number>& value);
                    
    
                       /**
                        * \brief Setter for member variable \ref ParamAssign.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref ParamAssign.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    
    
                       /**
                        * \brief Setter for member variable \ref ParamAssign.limit (rvalue reference)
                        */
                       void set_limit(std::shared_ptr<Limits>&& limit);

                       /**
                        * \brief Setter for member variable \ref ParamAssign.limit
                        */
                       void set_limit(const std::shared_ptr<Limits>& limit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PARAM_ASSIGN_HPP
#ifndef NMODL_AST_STEPPED_HPP
#define NMODL_AST_STEPPED_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class Stepped : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      NumberVector values;
    /// TODO
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Stepped(Name* name, NumberVector values, Unit* unit);
      explicit Stepped(const std::shared_ptr<Name>& name, const NumberVector& values, const std::shared_ptr<Unit>& unit);
    Stepped(const Stepped& obj);


  virtual ~Stepped() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Stepped
   * \return true as object is of type ast::Stepped
   */
  bool is_stepped () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Stepped* clone() const override {
    return new Stepped(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::STEPPED
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::STEPPED;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Stepped"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Stepped";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Stepped>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Stepped>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Stepped.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Stepped.values
                    */
                   const NumberVector& get_values() const noexcept  {
                       return values;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Stepped.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Stepped.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref Stepped.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Stepped.values (rvalue reference)
                        */
                       void set_values(NumberVector&& values);

                       /**
                        * \brief Setter for member variable \ref Stepped.values
                        */
                       void set_values(const NumberVector& values);
                    
    
                       /**
                        * \brief Setter for member variable \ref Stepped.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref Stepped.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_STEPPED_HPP
#ifndef NMODL_AST_INDEPENDENT_DEFINITION_HPP
#define NMODL_AST_INDEPENDENT_DEFINITION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class IndependentDefinition : public Statement {
  private:
    /// TODO
      std::shared_ptr<Boolean> sweep;
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<Number> from;
    /// TODO
      std::shared_ptr<Number> to;
    /// TODO
      std::shared_ptr<Integer> with;
    /// TODO
      std::shared_ptr<Number> start;
    /// TODO
      std::shared_ptr<Unit> unit;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit IndependentDefinition(Boolean* sweep, Name* name, Number* from, Number* to, Integer* with, Number* start, Unit* unit);
      explicit IndependentDefinition(const std::shared_ptr<Boolean>& sweep, const std::shared_ptr<Name>& name, const std::shared_ptr<Number>& from, const std::shared_ptr<Number>& to, const std::shared_ptr<Integer>& with, const std::shared_ptr<Number>& start, const std::shared_ptr<Unit>& unit);
    IndependentDefinition(const IndependentDefinition& obj);


  virtual ~IndependentDefinition() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::IndependentDefinition
   * \return true as object is of type ast::IndependentDefinition
   */
  bool is_independent_definition () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   IndependentDefinition* clone() const override {
    return new IndependentDefinition(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::INDEPENDENT_DEFINITION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::INDEPENDENT_DEFINITION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IndependentDefinition"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "IndependentDefinition";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IndependentDefinition>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IndependentDefinition>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.sweep
                    */
                   const std::shared_ptr<Boolean>& get_sweep() const noexcept  {
                       return sweep;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.from
                    */
                   const std::shared_ptr<Number>& get_from() const noexcept  {
                       return from;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.to
                    */
                   const std::shared_ptr<Number>& get_to() const noexcept  {
                       return to;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.with
                    */
                   const std::shared_ptr<Integer>& get_with() const noexcept  {
                       return with;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.start
                    */
                   const std::shared_ptr<Number>& get_start() const noexcept  {
                       return start;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IndependentDefinition.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.sweep (rvalue reference)
                        */
                       void set_sweep(std::shared_ptr<Boolean>&& sweep);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.sweep
                        */
                       void set_sweep(const std::shared_ptr<Boolean>& sweep);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.from (rvalue reference)
                        */
                       void set_from(std::shared_ptr<Number>&& from);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.from
                        */
                       void set_from(const std::shared_ptr<Number>& from);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.to (rvalue reference)
                        */
                       void set_to(std::shared_ptr<Number>&& to);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.to
                        */
                       void set_to(const std::shared_ptr<Number>& to);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.with (rvalue reference)
                        */
                       void set_with(std::shared_ptr<Integer>&& with);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.with
                        */
                       void set_with(const std::shared_ptr<Integer>& with);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.start (rvalue reference)
                        */
                       void set_start(std::shared_ptr<Number>&& start);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.start
                        */
                       void set_start(const std::shared_ptr<Number>& start);
                    
    
                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref IndependentDefinition.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_INDEPENDENT_DEFINITION_HPP
#ifndef NMODL_AST_ASSIGNED_DEFINITION_HPP
#define NMODL_AST_ASSIGNED_DEFINITION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a statement in `ASSIGNED` or `STATE` block
 *
 * 
*/
class AssignedDefinition : public Statement {
  private:
    /// Name of the variable
      std::shared_ptr<Identifier> name;
    /// Length in case of array
      std::shared_ptr<Integer> length;
    /// TODO
      std::shared_ptr<Number> from;
    /// TODO
      std::shared_ptr<Number> to;
    /// TODO
      std::shared_ptr<Number> start;
    /// TODO
      std::shared_ptr<Unit> unit;
    /// TODO
      std::shared_ptr<Double> abstol;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit AssignedDefinition(Identifier* name, Integer* length, Number* from, Number* to, Number* start, Unit* unit, Double* abstol);
      explicit AssignedDefinition(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Integer>& length, const std::shared_ptr<Number>& from, const std::shared_ptr<Number>& to, const std::shared_ptr<Number>& start, const std::shared_ptr<Unit>& unit, const std::shared_ptr<Double>& abstol);
    AssignedDefinition(const AssignedDefinition& obj);


  virtual ~AssignedDefinition() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::AssignedDefinition
   * \return true as object is of type ast::AssignedDefinition
   */
  bool is_assigned_definition () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   AssignedDefinition* clone() const override {
    return new AssignedDefinition(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ASSIGNED_DEFINITION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ASSIGNED_DEFINITION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "AssignedDefinition"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "AssignedDefinition";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<AssignedDefinition>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const AssignedDefinition>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Identifier has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.length
                    */
                   const std::shared_ptr<Integer>& get_length() const noexcept  {
                       return length;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.from
                    */
                   const std::shared_ptr<Number>& get_from() const noexcept  {
                       return from;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.to
                    */
                   const std::shared_ptr<Number>& get_to() const noexcept  {
                       return to;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.start
                    */
                   const std::shared_ptr<Number>& get_start() const noexcept  {
                       return start;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.unit
                    */
                   const std::shared_ptr<Unit>& get_unit() const noexcept  {
                       return unit;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref AssignedDefinition.abstol
                    */
                   const std::shared_ptr<Double>& get_abstol() const noexcept  {
                       return abstol;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.length (rvalue reference)
                        */
                       void set_length(std::shared_ptr<Integer>&& length);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.length
                        */
                       void set_length(const std::shared_ptr<Integer>& length);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.from (rvalue reference)
                        */
                       void set_from(std::shared_ptr<Number>&& from);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.from
                        */
                       void set_from(const std::shared_ptr<Number>& from);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.to (rvalue reference)
                        */
                       void set_to(std::shared_ptr<Number>&& to);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.to
                        */
                       void set_to(const std::shared_ptr<Number>& to);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.start (rvalue reference)
                        */
                       void set_start(std::shared_ptr<Number>&& start);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.start
                        */
                       void set_start(const std::shared_ptr<Number>& start);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.unit (rvalue reference)
                        */
                       void set_unit(std::shared_ptr<Unit>&& unit);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.unit
                        */
                       void set_unit(const std::shared_ptr<Unit>& unit);
                    
    
                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.abstol (rvalue reference)
                        */
                       void set_abstol(std::shared_ptr<Double>&& abstol);

                       /**
                        * \brief Setter for member variable \ref AssignedDefinition.abstol
                        */
                       void set_abstol(const std::shared_ptr<Double>& abstol);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ASSIGNED_DEFINITION_HPP
#ifndef NMODL_AST_PLOT_DECLARATION_HPP
#define NMODL_AST_PLOT_DECLARATION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PlotDeclaration : public Statement {
  private:
    /// TODO
      PlotVarVector variables;
    /// TODO
      std::shared_ptr<PlotVar> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PlotDeclaration(PlotVarVector variables, PlotVar* name);
      explicit PlotDeclaration(const PlotVarVector& variables, const std::shared_ptr<PlotVar>& name);
    PlotDeclaration(const PlotDeclaration& obj);


  virtual ~PlotDeclaration() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PlotDeclaration
   * \return true as object is of type ast::PlotDeclaration
   */
  bool is_plot_declaration () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PlotDeclaration* clone() const override {
    return new PlotDeclaration(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PLOT_DECLARATION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PLOT_DECLARATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PlotDeclaration"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PlotDeclaration";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "PLOT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "PLOT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PlotDeclaration>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PlotDeclaration>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref PlotDeclaration.variables
                    */
                   const PlotVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PlotDeclaration.name
                    */
                   const std::shared_ptr<PlotVar>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PlotDeclaration.variables (rvalue reference)
                        */
                       void set_variables(PlotVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref PlotDeclaration.variables
                        */
                       void set_variables(const PlotVarVector& variables);
                    
    
                       /**
                        * \brief Setter for member variable \ref PlotDeclaration.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<PlotVar>&& name);

                       /**
                        * \brief Setter for member variable \ref PlotDeclaration.name
                        */
                       void set_name(const std::shared_ptr<PlotVar>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PLOT_DECLARATION_HPP
#ifndef NMODL_AST_CONDUCTANCE_HINT_HPP
#define NMODL_AST_CONDUCTANCE_HINT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents `CONDUCTANCE` statement in NMODL
 *
 * If `I/V` relation in the `BREAKPOINT` block is ohomic then one can
  * specify `CONDUCTANCE` hint for optimised code generation:
  * 
  * \code{.mod}
  *     CONDUCTANCE g USEION I
  * \endcode
  * 
  * \sa nmodl::visitor::SympyConductanceVisitor
  * 
*/
class ConductanceHint : public Statement {
  private:
    /// Conductance variable
      std::shared_ptr<Name> conductance;
    /// Ion name
      std::shared_ptr<Name> ion;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ConductanceHint(Name* conductance, Name* ion);
      explicit ConductanceHint(const std::shared_ptr<Name>& conductance, const std::shared_ptr<Name>& ion);
    ConductanceHint(const ConductanceHint& obj);


  virtual ~ConductanceHint() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ConductanceHint
   * \return true as object is of type ast::ConductanceHint
   */
  bool is_conductance_hint () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ConductanceHint* clone() const override {
    return new ConductanceHint(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONDUCTANCE_HINT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONDUCTANCE_HINT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConductanceHint"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ConductanceHint";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "CONDUCTANCE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "CONDUCTANCE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConductanceHint>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConductanceHint>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ConductanceHint.conductance
                    */
                   const std::shared_ptr<Name>& get_conductance() const noexcept  {
                       return conductance;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ConductanceHint.ion
                    */
                   const std::shared_ptr<Name>& get_ion() const noexcept  {
                       return ion;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ConductanceHint.conductance (rvalue reference)
                        */
                       void set_conductance(std::shared_ptr<Name>&& conductance);

                       /**
                        * \brief Setter for member variable \ref ConductanceHint.conductance
                        */
                       void set_conductance(const std::shared_ptr<Name>& conductance);
                    
    
                       /**
                        * \brief Setter for member variable \ref ConductanceHint.ion (rvalue reference)
                        */
                       void set_ion(std::shared_ptr<Name>&& ion);

                       /**
                        * \brief Setter for member variable \ref ConductanceHint.ion
                        */
                       void set_ion(const std::shared_ptr<Name>& ion);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONDUCTANCE_HINT_HPP
#ifndef NMODL_AST_EXPRESSION_STATEMENT_HPP
#define NMODL_AST_EXPRESSION_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ExpressionStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ExpressionStatement(Expression* expression);
      explicit ExpressionStatement(const std::shared_ptr<Expression>& expression);
    ExpressionStatement(const ExpressionStatement& obj);


  virtual ~ExpressionStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ExpressionStatement
   * \return true as object is of type ast::ExpressionStatement
   */
  bool is_expression_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ExpressionStatement* clone() const override {
    return new ExpressionStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXPRESSION_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXPRESSION_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ExpressionStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ExpressionStatement";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ExpressionStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ExpressionStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ExpressionStatement.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ExpressionStatement.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref ExpressionStatement.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EXPRESSION_STATEMENT_HPP
#ifndef NMODL_AST_PROTECT_STATEMENT_HPP
#define NMODL_AST_PROTECT_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ProtectStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ProtectStatement(Expression* expression);
      explicit ProtectStatement(const std::shared_ptr<Expression>& expression);
    ProtectStatement(const ProtectStatement& obj);


  virtual ~ProtectStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ProtectStatement
   * \return true as object is of type ast::ProtectStatement
   */
  bool is_protect_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ProtectStatement* clone() const override {
    return new ProtectStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROTECT_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROTECT_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ProtectStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ProtectStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "PROTECT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "PROTECT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ProtectStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ProtectStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ProtectStatement.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ProtectStatement.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref ProtectStatement.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PROTECT_STATEMENT_HPP
#ifndef NMODL_AST_FROM_STATEMENT_HPP
#define NMODL_AST_FROM_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class FromStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<Expression> from;
    /// TODO
      std::shared_ptr<Expression> to;
    /// TODO
      std::shared_ptr<Expression> increment;
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit FromStatement(Name* name, Expression* from, Expression* to, Expression* increment, StatementBlock* statement_block);
      explicit FromStatement(const std::shared_ptr<Name>& name, const std::shared_ptr<Expression>& from, const std::shared_ptr<Expression>& to, const std::shared_ptr<Expression>& increment, const std::shared_ptr<StatementBlock>& statement_block);
    FromStatement(const FromStatement& obj);


  virtual ~FromStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::FromStatement
   * \return true as object is of type ast::FromStatement
   */
  bool is_from_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   FromStatement* clone() const override {
    return new FromStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FROM_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FROM_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "FromStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "FromStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "FROM "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "FROM ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<FromStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const FromStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref FromStatement.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FromStatement.from
                    */
                   const std::shared_ptr<Expression>& get_from() const noexcept  {
                       return from;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FromStatement.to
                    */
                   const std::shared_ptr<Expression>& get_to() const noexcept  {
                       return to;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FromStatement.increment
                    */
                   const std::shared_ptr<Expression>& get_increment() const noexcept  {
                       return increment;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref FromStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref FromStatement.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref FromStatement.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref FromStatement.from (rvalue reference)
                        */
                       void set_from(std::shared_ptr<Expression>&& from);

                       /**
                        * \brief Setter for member variable \ref FromStatement.from
                        */
                       void set_from(const std::shared_ptr<Expression>& from);
                    
    
                       /**
                        * \brief Setter for member variable \ref FromStatement.to (rvalue reference)
                        */
                       void set_to(std::shared_ptr<Expression>&& to);

                       /**
                        * \brief Setter for member variable \ref FromStatement.to
                        */
                       void set_to(const std::shared_ptr<Expression>& to);
                    
    
                       /**
                        * \brief Setter for member variable \ref FromStatement.increment (rvalue reference)
                        */
                       void set_increment(std::shared_ptr<Expression>&& increment);

                       /**
                        * \brief Setter for member variable \ref FromStatement.increment
                        */
                       void set_increment(const std::shared_ptr<Expression>& increment);
                    
    
                       /**
                        * \brief Setter for member variable \ref FromStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref FromStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FROM_STATEMENT_HPP
#ifndef NMODL_AST_FOR_ALL_STATEMENT_HPP
#define NMODL_AST_FOR_ALL_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ForAllStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ForAllStatement(Name* name, StatementBlock* statement_block);
      explicit ForAllStatement(const std::shared_ptr<Name>& name, const std::shared_ptr<StatementBlock>& statement_block);
    ForAllStatement(const ForAllStatement& obj);


  virtual ~ForAllStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ForAllStatement
   * \return true as object is of type ast::ForAllStatement
   */
  bool is_for_all_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ForAllStatement* clone() const override {
    return new ForAllStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::FOR_ALL_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::FOR_ALL_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ForAllStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ForAllStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "FORALL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "FORALL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ForAllStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ForAllStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ForAllStatement.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ForAllStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ForAllStatement.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref ForAllStatement.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref ForAllStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ForAllStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_FOR_ALL_STATEMENT_HPP
#ifndef NMODL_AST_WHILE_STATEMENT_HPP
#define NMODL_AST_WHILE_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class WhileStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> condition;
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit WhileStatement(Expression* condition, StatementBlock* statement_block);
      explicit WhileStatement(const std::shared_ptr<Expression>& condition, const std::shared_ptr<StatementBlock>& statement_block);
    WhileStatement(const WhileStatement& obj);


  virtual ~WhileStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::WhileStatement
   * \return true as object is of type ast::WhileStatement
   */
  bool is_while_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   WhileStatement* clone() const override {
    return new WhileStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WHILE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WHILE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WhileStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "WhileStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "WHILE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "WHILE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WhileStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WhileStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref WhileStatement.condition
                    */
                   const std::shared_ptr<Expression>& get_condition() const noexcept  {
                       return condition;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref WhileStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref WhileStatement.condition (rvalue reference)
                        */
                       void set_condition(std::shared_ptr<Expression>&& condition);

                       /**
                        * \brief Setter for member variable \ref WhileStatement.condition
                        */
                       void set_condition(const std::shared_ptr<Expression>& condition);
                    
    
                       /**
                        * \brief Setter for member variable \ref WhileStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref WhileStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_WHILE_STATEMENT_HPP
#ifndef NMODL_AST_IF_STATEMENT_HPP
#define NMODL_AST_IF_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class IfStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> condition;
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// TODO
      ElseIfStatementVector elseifs;
    /// TODO
      std::shared_ptr<ElseStatement> elses;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit IfStatement(Expression* condition, StatementBlock* statement_block, ElseIfStatementVector elseifs, ElseStatement* elses);
      explicit IfStatement(const std::shared_ptr<Expression>& condition, const std::shared_ptr<StatementBlock>& statement_block, const ElseIfStatementVector& elseifs, const std::shared_ptr<ElseStatement>& elses);
    IfStatement(const IfStatement& obj);


  virtual ~IfStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::IfStatement
   * \return true as object is of type ast::IfStatement
   */
  bool is_if_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   IfStatement* clone() const override {
    return new IfStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::IF_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::IF_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "IfStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "IfStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "IF "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "IF ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<IfStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const IfStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref IfStatement.condition
                    */
                   const std::shared_ptr<Expression>& get_condition() const noexcept  {
                       return condition;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IfStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IfStatement.elseifs
                    */
                   const ElseIfStatementVector& get_elseifs() const noexcept  {
                       return elseifs;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref IfStatement.elses
                    */
                   const std::shared_ptr<ElseStatement>& get_elses() const noexcept  {
                       return elses;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref IfStatement.condition (rvalue reference)
                        */
                       void set_condition(std::shared_ptr<Expression>&& condition);

                       /**
                        * \brief Setter for member variable \ref IfStatement.condition
                        */
                       void set_condition(const std::shared_ptr<Expression>& condition);
                    
    
                       /**
                        * \brief Setter for member variable \ref IfStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref IfStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref IfStatement.elseifs (rvalue reference)
                        */
                       void set_elseifs(ElseIfStatementVector&& elseifs);

                       /**
                        * \brief Setter for member variable \ref IfStatement.elseifs
                        */
                       void set_elseifs(const ElseIfStatementVector& elseifs);
                    
    
                       /**
                        * \brief Setter for member variable \ref IfStatement.elses (rvalue reference)
                        */
                       void set_elses(std::shared_ptr<ElseStatement>&& elses);

                       /**
                        * \brief Setter for member variable \ref IfStatement.elses
                        */
                       void set_elses(const std::shared_ptr<ElseStatement>& elses);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_IF_STATEMENT_HPP
#ifndef NMODL_AST_ELSE_IF_STATEMENT_HPP
#define NMODL_AST_ELSE_IF_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ElseIfStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> condition;
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ElseIfStatement(Expression* condition, StatementBlock* statement_block);
      explicit ElseIfStatement(const std::shared_ptr<Expression>& condition, const std::shared_ptr<StatementBlock>& statement_block);
    ElseIfStatement(const ElseIfStatement& obj);


  virtual ~ElseIfStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ElseIfStatement
   * \return true as object is of type ast::ElseIfStatement
   */
  bool is_else_if_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ElseIfStatement* clone() const override {
    return new ElseIfStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELSE_IF_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELSE_IF_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElseIfStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ElseIfStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. " ELSE IF "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return " ELSE IF ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElseIfStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElseIfStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ElseIfStatement.condition
                    */
                   const std::shared_ptr<Expression>& get_condition() const noexcept  {
                       return condition;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ElseIfStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ElseIfStatement.condition (rvalue reference)
                        */
                       void set_condition(std::shared_ptr<Expression>&& condition);

                       /**
                        * \brief Setter for member variable \ref ElseIfStatement.condition
                        */
                       void set_condition(const std::shared_ptr<Expression>& condition);
                    
    
                       /**
                        * \brief Setter for member variable \ref ElseIfStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ElseIfStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ELSE_IF_STATEMENT_HPP
#ifndef NMODL_AST_ELSE_STATEMENT_HPP
#define NMODL_AST_ELSE_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ElseStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<StatementBlock> statement_block;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ElseStatement(StatementBlock* statement_block);
      explicit ElseStatement(const std::shared_ptr<StatementBlock>& statement_block);
    ElseStatement(const ElseStatement& obj);


  virtual ~ElseStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ElseStatement
   * \return true as object is of type ast::ElseStatement
   */
  bool is_else_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ElseStatement* clone() const override {
    return new ElseStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELSE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELSE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElseStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ElseStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. " ELSE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return " ELSE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElseStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElseStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ElseStatement.statement_block
                    */
                   const std::shared_ptr<StatementBlock>& get_statement_block() const noexcept  override {
                       return statement_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ElseStatement.statement_block (rvalue reference)
                        */
                       void set_statement_block(std::shared_ptr<StatementBlock>&& statement_block);

                       /**
                        * \brief Setter for member variable \ref ElseStatement.statement_block
                        */
                       void set_statement_block(const std::shared_ptr<StatementBlock>& statement_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ELSE_STATEMENT_HPP
#ifndef NMODL_AST_PARTIAL_EQUATION_HPP
#define NMODL_AST_PARTIAL_EQUATION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PartialEquation : public Statement {
  private:
    /// TODO
      std::shared_ptr<PrimeName> prime;
    /// TODO
      std::shared_ptr<Name> name1;
    /// TODO
      std::shared_ptr<Name> name2;
    /// TODO
      std::shared_ptr<Name> name3;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PartialEquation(PrimeName* prime, Name* name1, Name* name2, Name* name3);
      explicit PartialEquation(const std::shared_ptr<PrimeName>& prime, const std::shared_ptr<Name>& name1, const std::shared_ptr<Name>& name2, const std::shared_ptr<Name>& name3);
    PartialEquation(const PartialEquation& obj);


  virtual ~PartialEquation() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PartialEquation
   * \return true as object is of type ast::PartialEquation
   */
  bool is_partial_equation () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PartialEquation* clone() const override {
    return new PartialEquation(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_EQUATION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_EQUATION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialEquation"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PartialEquation";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialEquation>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialEquation>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialEquation.prime
                    */
                   const std::shared_ptr<PrimeName>& get_prime() const noexcept  {
                       return prime;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialEquation.name1
                    */
                   const std::shared_ptr<Name>& get_name1() const noexcept  {
                       return name1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialEquation.name2
                    */
                   const std::shared_ptr<Name>& get_name2() const noexcept  {
                       return name2;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialEquation.name3
                    */
                   const std::shared_ptr<Name>& get_name3() const noexcept  {
                       return name3;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PartialEquation.prime (rvalue reference)
                        */
                       void set_prime(std::shared_ptr<PrimeName>&& prime);

                       /**
                        * \brief Setter for member variable \ref PartialEquation.prime
                        */
                       void set_prime(const std::shared_ptr<PrimeName>& prime);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialEquation.name1 (rvalue reference)
                        */
                       void set_name1(std::shared_ptr<Name>&& name1);

                       /**
                        * \brief Setter for member variable \ref PartialEquation.name1
                        */
                       void set_name1(const std::shared_ptr<Name>& name1);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialEquation.name2 (rvalue reference)
                        */
                       void set_name2(std::shared_ptr<Name>&& name2);

                       /**
                        * \brief Setter for member variable \ref PartialEquation.name2
                        */
                       void set_name2(const std::shared_ptr<Name>& name2);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialEquation.name3 (rvalue reference)
                        */
                       void set_name3(std::shared_ptr<Name>&& name3);

                       /**
                        * \brief Setter for member variable \ref PartialEquation.name3
                        */
                       void set_name3(const std::shared_ptr<Name>& name3);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PARTIAL_EQUATION_HPP
#ifndef NMODL_AST_PARTIAL_BOUNDARY_HPP
#define NMODL_AST_PARTIAL_BOUNDARY_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class PartialBoundary : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> del;
    /// TODO
      std::shared_ptr<Identifier> name;
    /// TODO
      std::shared_ptr<FirstLastTypeIndex> index;
    /// TODO
      std::shared_ptr<Expression> expression;
    /// TODO
      std::shared_ptr<Name> name1;
    /// TODO
      std::shared_ptr<Name> del2;
    /// TODO
      std::shared_ptr<Name> name2;
    /// TODO
      std::shared_ptr<Name> name3;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit PartialBoundary(Name* del, Identifier* name, FirstLastTypeIndex* index, Expression* expression, Name* name1, Name* del2, Name* name2, Name* name3);
      explicit PartialBoundary(const std::shared_ptr<Name>& del, const std::shared_ptr<Identifier>& name, const std::shared_ptr<FirstLastTypeIndex>& index, const std::shared_ptr<Expression>& expression, const std::shared_ptr<Name>& name1, const std::shared_ptr<Name>& del2, const std::shared_ptr<Name>& name2, const std::shared_ptr<Name>& name3);
    PartialBoundary(const PartialBoundary& obj);


  virtual ~PartialBoundary() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::PartialBoundary
   * \return true as object is of type ast::PartialBoundary
   */
  bool is_partial_boundary () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   PartialBoundary* clone() const override {
    return new PartialBoundary(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PARTIAL_BOUNDARY
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PARTIAL_BOUNDARY;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "PartialBoundary"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "PartialBoundary";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "~ "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "~ ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<PartialBoundary>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const PartialBoundary>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.del
                    */
                   const std::shared_ptr<Name>& get_del() const noexcept  {
                       return del;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.index
                    */
                   const std::shared_ptr<FirstLastTypeIndex>& get_index() const noexcept  {
                       return index;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.name1
                    */
                   const std::shared_ptr<Name>& get_name1() const noexcept  {
                       return name1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.del2
                    */
                   const std::shared_ptr<Name>& get_del2() const noexcept  {
                       return del2;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.name2
                    */
                   const std::shared_ptr<Name>& get_name2() const noexcept  {
                       return name2;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref PartialBoundary.name3
                    */
                   const std::shared_ptr<Name>& get_name3() const noexcept  {
                       return name3;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.del (rvalue reference)
                        */
                       void set_del(std::shared_ptr<Name>&& del);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.del
                        */
                       void set_del(const std::shared_ptr<Name>& del);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.index (rvalue reference)
                        */
                       void set_index(std::shared_ptr<FirstLastTypeIndex>&& index);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.index
                        */
                       void set_index(const std::shared_ptr<FirstLastTypeIndex>& index);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name1 (rvalue reference)
                        */
                       void set_name1(std::shared_ptr<Name>&& name1);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name1
                        */
                       void set_name1(const std::shared_ptr<Name>& name1);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.del2 (rvalue reference)
                        */
                       void set_del2(std::shared_ptr<Name>&& del2);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.del2
                        */
                       void set_del2(const std::shared_ptr<Name>& del2);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name2 (rvalue reference)
                        */
                       void set_name2(std::shared_ptr<Name>&& name2);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name2
                        */
                       void set_name2(const std::shared_ptr<Name>& name2);
                    
    
                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name3 (rvalue reference)
                        */
                       void set_name3(std::shared_ptr<Name>&& name3);

                       /**
                        * \brief Setter for member variable \ref PartialBoundary.name3
                        */
                       void set_name3(const std::shared_ptr<Name>& name3);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PARTIAL_BOUNDARY_HPP
#ifndef NMODL_AST_WATCH_STATEMENT_HPP
#define NMODL_AST_WATCH_STATEMENT_HPP
#define NMODL_AST_WATCH_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent WATCH statement in NMODL
 *
 * 
*/
class WatchStatement : public Statement {
  private:
    /// Vector of watch statements
      WatchVector statements;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit WatchStatement(WatchVector statements);
    WatchStatement(const WatchStatement& obj);


  virtual ~WatchStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::WatchStatement
   * \return true as object is of type ast::WatchStatement
   */
  bool is_watch_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   WatchStatement* clone() const override {
    return new WatchStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WATCH_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WATCH_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WatchStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "WatchStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "WATCH "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "WATCH ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WatchStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WatchStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    
/**
 * \brief Add member to statements by raw pointer
 */
void emplace_back_watch(Watch *n);

/**
 * \brief Add member to statements by shared_ptr
 */
void emplace_back_watch(std::shared_ptr<Watch> n);

/**
 * \brief Erase member to statements
 */
WatchVector::const_iterator erase_watch(WatchVector::const_iterator first);

/**
 * \brief Erase members to statements
 */
WatchVector::const_iterator erase_watch(WatchVector::const_iterator first, WatchVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to statements
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_watch(std::unordered_set<Watch*>& to_be_erased);

/**
 * \brief Insert member to statements
 */
WatchVector::const_iterator insert_watch(WatchVector::const_iterator position, const std::shared_ptr<Watch>& n);

/**
 * \brief Insert members to statements
 */
template <class NodeType, class InputIterator>
void insert_watch(WatchVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to statements
 */
void reset_watch(WatchVector::const_iterator position, Watch* n);

/**
 * \brief Reset member to statements
 */
void reset_watch(WatchVector::const_iterator position, std::shared_ptr<Watch> n);


    

    
                   /**
                    * \brief Getter for member variable \ref WatchStatement.statements
                    */
                   const WatchVector& get_statements() const noexcept  {
                       return statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref WatchStatement.statements (rvalue reference)
                        */
                       void set_statements(WatchVector&& statements);

                       /**
                        * \brief Setter for member variable \ref WatchStatement.statements
                        */
                       void set_statements(const WatchVector& statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_WATCH_STATEMENT_HPP
#ifndef NMODL_AST_MUTEX_LOCK_HPP
#define NMODL_AST_MUTEX_LOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent MUTEXLOCK statement in NMODL
 *
 * 
*/
class MutexLock : public Statement {
  private:
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~MutexLock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::MutexLock
   * \return true as object is of type ast::MutexLock
   */
  bool is_mutex_lock () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   MutexLock* clone() const override {
    return new MutexLock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MUTEX_LOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MUTEX_LOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MutexLock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "MutexLock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "MUTEXLOCK"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "MUTEXLOCK";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MutexLock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MutexLock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }




  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }




  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_MUTEX_LOCK_HPP
#ifndef NMODL_AST_MUTEX_UNLOCK_HPP
#define NMODL_AST_MUTEX_UNLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent MUTEXUNLOCK statement in NMODL
 *
 * 
*/
class MutexUnlock : public Statement {
  private:
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~MutexUnlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::MutexUnlock
   * \return true as object is of type ast::MutexUnlock
   */
  bool is_mutex_unlock () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   MutexUnlock* clone() const override {
    return new MutexUnlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::MUTEX_UNLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::MUTEX_UNLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "MutexUnlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "MutexUnlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "MUTEXUNLOCK"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "MUTEXUNLOCK";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<MutexUnlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const MutexUnlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }




  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }




  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_MUTEX_UNLOCK_HPP
#ifndef NMODL_AST_RESET_HPP
#define NMODL_AST_RESET_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent RESET statement in NMODL
 *
 * 
*/
class Reset : public Statement {
  private:
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{



  virtual ~Reset() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Reset
   * \return true as object is of type ast::Reset
   */
  bool is_reset () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Reset* clone() const override {
    return new Reset(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RESET
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RESET;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Reset"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Reset";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "RESET"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "RESET";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Reset>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Reset>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }




  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }




  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_RESET_HPP
#ifndef NMODL_AST_SENS_HPP
#define NMODL_AST_SENS_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent SENS statement in NMODL
 *
 * 
*/
class Sens : public Statement {
  private:
    /// TODO
      VarNameVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Sens(VarNameVector variables);
    Sens(const Sens& obj);


  virtual ~Sens() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Sens
   * \return true as object is of type ast::Sens
   */
  bool is_sens () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Sens* clone() const override {
    return new Sens(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SENS
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SENS;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Sens"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Sens";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "SENS "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "SENS ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Sens>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Sens>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Sens.variables
                    */
                   const VarNameVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Sens.variables (rvalue reference)
                        */
                       void set_variables(VarNameVector&& variables);

                       /**
                        * \brief Setter for member variable \ref Sens.variables
                        */
                       void set_variables(const VarNameVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SENS_HPP
#ifndef NMODL_AST_CONSERVE_HPP
#define NMODL_AST_CONSERVE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent CONSERVE statement in NMODL
 *
 * 
*/
class Conserve : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> react;
    /// TODO
      std::shared_ptr<Expression> expr;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Conserve(Expression* react, Expression* expr);
      explicit Conserve(const std::shared_ptr<Expression>& react, const std::shared_ptr<Expression>& expr);
    Conserve(const Conserve& obj);


  virtual ~Conserve() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Conserve
   * \return true as object is of type ast::Conserve
   */
  bool is_conserve () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Conserve* clone() const override {
    return new Conserve(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSERVE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSERVE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Conserve"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Conserve";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "CONSERVE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "CONSERVE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Conserve>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Conserve>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Conserve.react
                    */
                   const std::shared_ptr<Expression>& get_react() const noexcept  {
                       return react;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Conserve.expr
                    */
                   const std::shared_ptr<Expression>& get_expr() const noexcept  {
                       return expr;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Conserve.react (rvalue reference)
                        */
                       void set_react(std::shared_ptr<Expression>&& react);

                       /**
                        * \brief Setter for member variable \ref Conserve.react
                        */
                       void set_react(const std::shared_ptr<Expression>& react);
                    
    
                       /**
                        * \brief Setter for member variable \ref Conserve.expr (rvalue reference)
                        */
                       void set_expr(std::shared_ptr<Expression>&& expr);

                       /**
                        * \brief Setter for member variable \ref Conserve.expr
                        */
                       void set_expr(const std::shared_ptr<Expression>& expr);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONSERVE_HPP
#ifndef NMODL_AST_COMPARTMENT_HPP
#define NMODL_AST_COMPARTMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent COMPARTMENT statement in NMODL
 *
 * 
*/
class Compartment : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<Expression> expression;
    /// TODO
      NameVector names;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Compartment(Name* name, Expression* expression, NameVector names);
      explicit Compartment(const std::shared_ptr<Name>& name, const std::shared_ptr<Expression>& expression, const NameVector& names);
    Compartment(const Compartment& obj);


  virtual ~Compartment() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Compartment
   * \return true as object is of type ast::Compartment
   */
  bool is_compartment () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Compartment* clone() const override {
    return new Compartment(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::COMPARTMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::COMPARTMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Compartment"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Compartment";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "COMPARTMENT"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "COMPARTMENT";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Compartment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Compartment>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Compartment.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Compartment.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Compartment.names
                    */
                   const NameVector& get_names() const noexcept  {
                       return names;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Compartment.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref Compartment.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Compartment.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref Compartment.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    
    
                       /**
                        * \brief Setter for member variable \ref Compartment.names (rvalue reference)
                        */
                       void set_names(NameVector&& names);

                       /**
                        * \brief Setter for member variable \ref Compartment.names
                        */
                       void set_names(const NameVector& names);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_COMPARTMENT_HPP
#ifndef NMODL_AST_LON_DIFUSE_HPP
#define NMODL_AST_LON_DIFUSE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent LONGITUDINAL_DIFFUSION statement in NMODL
 *
 * 
*/
class LonDifuse : public Statement {
  private:
    /// TODO
      std::shared_ptr<Name> name;
    /// TODO
      std::shared_ptr<Expression> expression;
    /// TODO
      NameVector names;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LonDifuse(Name* name, Expression* expression, NameVector names);
      explicit LonDifuse(const std::shared_ptr<Name>& name, const std::shared_ptr<Expression>& expression, const NameVector& names);
    LonDifuse(const LonDifuse& obj);


  virtual ~LonDifuse() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LonDifuse
   * \return true as object is of type ast::LonDifuse
   */
  bool is_lon_difuse () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LonDifuse* clone() const override {
    return new LonDifuse(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LON_DIFUSE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LON_DIFUSE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LonDifuse"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LonDifuse";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "LONGITUDINAL_DIFFUSION"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "LONGITUDINAL_DIFFUSION";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LonDifuse>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LonDifuse>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref LonDifuse.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LonDifuse.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LonDifuse.names
                    */
                   const NameVector& get_names() const noexcept  {
                       return names;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LonDifuse.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref LonDifuse.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref LonDifuse.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref LonDifuse.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    
    
                       /**
                        * \brief Setter for member variable \ref LonDifuse.names (rvalue reference)
                        */
                       void set_names(NameVector&& names);

                       /**
                        * \brief Setter for member variable \ref LonDifuse.names
                        */
                       void set_names(const NameVector& names);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LON_DIFUSE_HPP
#ifndef NMODL_AST_REACTION_STATEMENT_HPP
#define NMODL_AST_REACTION_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief TODO
 *
 * 
*/
class ReactionStatement : public Statement {
  private:
    /// TODO
      std::shared_ptr<Expression> reaction1;
    /// TODO
      ReactionOperator op;
    /// TODO
      std::shared_ptr<Expression> reaction2;
    /// TODO
      std::shared_ptr<Expression> expression1;
    /// TODO
      std::shared_ptr<Expression> expression2;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ReactionStatement(Expression* reaction1, const ReactionOperator& op, Expression* reaction2, Expression* expression1, Expression* expression2);
      explicit ReactionStatement(const std::shared_ptr<Expression>& reaction1, const ReactionOperator& op, const std::shared_ptr<Expression>& reaction2, const std::shared_ptr<Expression>& expression1, const std::shared_ptr<Expression>& expression2);
    ReactionStatement(const ReactionStatement& obj);


  virtual ~ReactionStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ReactionStatement
   * \return true as object is of type ast::ReactionStatement
   */
  bool is_reaction_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ReactionStatement* clone() const override {
    return new ReactionStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::REACTION_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::REACTION_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ReactionStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ReactionStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "~ "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "~ ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ReactionStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ReactionStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionStatement.reaction1
                    */
                   const std::shared_ptr<Expression>& get_reaction1() const noexcept  {
                       return reaction1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionStatement.op
                    */
                   const ReactionOperator& get_op() const noexcept  {
                       return op;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionStatement.reaction2
                    */
                   const std::shared_ptr<Expression>& get_reaction2() const noexcept  {
                       return reaction2;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionStatement.expression1
                    */
                   const std::shared_ptr<Expression>& get_expression1() const noexcept  {
                       return expression1;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref ReactionStatement.expression2
                    */
                   const std::shared_ptr<Expression>& get_expression2() const noexcept  {
                       return expression2;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ReactionStatement.reaction1 (rvalue reference)
                        */
                       void set_reaction1(std::shared_ptr<Expression>&& reaction1);

                       /**
                        * \brief Setter for member variable \ref ReactionStatement.reaction1
                        */
                       void set_reaction1(const std::shared_ptr<Expression>& reaction1);
                    
    
                       /**
                        * \brief Setter for member variable \ref ReactionStatement.op (rvalue reference)
                        */
                       void set_op(ReactionOperator&& op);

                       /**
                        * \brief Setter for member variable \ref ReactionStatement.op
                        */
                       void set_op(const ReactionOperator& op);
                    
    
                       /**
                        * \brief Setter for member variable \ref ReactionStatement.reaction2 (rvalue reference)
                        */
                       void set_reaction2(std::shared_ptr<Expression>&& reaction2);

                       /**
                        * \brief Setter for member variable \ref ReactionStatement.reaction2
                        */
                       void set_reaction2(const std::shared_ptr<Expression>& reaction2);
                    
    
                       /**
                        * \brief Setter for member variable \ref ReactionStatement.expression1 (rvalue reference)
                        */
                       void set_expression1(std::shared_ptr<Expression>&& expression1);

                       /**
                        * \brief Setter for member variable \ref ReactionStatement.expression1
                        */
                       void set_expression1(const std::shared_ptr<Expression>& expression1);
                    
    
                       /**
                        * \brief Setter for member variable \ref ReactionStatement.expression2 (rvalue reference)
                        */
                       void set_expression2(std::shared_ptr<Expression>&& expression2);

                       /**
                        * \brief Setter for member variable \ref ReactionStatement.expression2
                        */
                       void set_expression2(const std::shared_ptr<Expression>& expression2);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_REACTION_STATEMENT_HPP
#ifndef NMODL_AST_LAG_STATEMENT_HPP
#define NMODL_AST_LAG_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a LAG statement in the mod file
 *
 * An example of LAG statement usage:
  * 
  * \code{.mod}
  *     PROCEDURE lates() {
  *         LAG ina BY tau
  *         neo = lag_ina_tau
  *         if (ena < 70) {ena = 70}
  *     }
  * \endcode
  * 
*/
class LagStatement : public Statement {
  private:
    /// Name of the variable (TODO)
      std::shared_ptr<Identifier> name;
    /// Name of the variable (TODO)
      std::shared_ptr<Name> byname;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LagStatement(Identifier* name, Name* byname);
      explicit LagStatement(const std::shared_ptr<Identifier>& name, const std::shared_ptr<Name>& byname);
    LagStatement(const LagStatement& obj);


  virtual ~LagStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LagStatement
   * \return true as object is of type ast::LagStatement
   */
  bool is_lag_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LagStatement* clone() const override {
    return new LagStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LAG_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LAG_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LagStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LagStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "LAG "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "LAG ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LagStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LagStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref LagStatement.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref LagStatement.byname
                    */
                   const std::shared_ptr<Name>& get_byname() const noexcept  {
                       return byname;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LagStatement.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref LagStatement.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref LagStatement.byname (rvalue reference)
                        */
                       void set_byname(std::shared_ptr<Name>&& byname);

                       /**
                        * \brief Setter for member variable \ref LagStatement.byname
                        */
                       void set_byname(const std::shared_ptr<Name>& byname);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LAG_STATEMENT_HPP
#ifndef NMODL_AST_QUEUE_STATEMENT_HPP
#define NMODL_AST_QUEUE_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent queue statement in NMODL
 *
 * 
*/
class QueueStatement : public Statement {
  private:
    /// queue type (put/get)
      std::shared_ptr<QueueExpressionType> qtype;
    /// Name of the variable
      std::shared_ptr<Identifier> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit QueueStatement(QueueExpressionType* qtype, Identifier* name);
      explicit QueueStatement(const std::shared_ptr<QueueExpressionType>& qtype, const std::shared_ptr<Identifier>& name);
    QueueStatement(const QueueStatement& obj);


  virtual ~QueueStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::QueueStatement
   * \return true as object is of type ast::QueueStatement
   */
  bool is_queue_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   QueueStatement* clone() const override {
    return new QueueStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::QUEUE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::QUEUE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "QueueStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "QueueStatement";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<QueueStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const QueueStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref QueueStatement.qtype
                    */
                   const std::shared_ptr<QueueExpressionType>& get_qtype() const noexcept  {
                       return qtype;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref QueueStatement.name
                    */
                   const std::shared_ptr<Identifier>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref QueueStatement.qtype (rvalue reference)
                        */
                       void set_qtype(std::shared_ptr<QueueExpressionType>&& qtype);

                       /**
                        * \brief Setter for member variable \ref QueueStatement.qtype
                        */
                       void set_qtype(const std::shared_ptr<QueueExpressionType>& qtype);
                    
    
                       /**
                        * \brief Setter for member variable \ref QueueStatement.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Identifier>&& name);

                       /**
                        * \brief Setter for member variable \ref QueueStatement.name
                        */
                       void set_name(const std::shared_ptr<Identifier>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_QUEUE_STATEMENT_HPP
#ifndef NMODL_AST_CONSTANT_STATEMENT_HPP
#define NMODL_AST_CONSTANT_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent statement in CONSTANT block of NMODL
 *
 * \todo As ConstantStatement wraps a single ConstantVar,
  *       this or ast::ConstantVar can be redundant in the future.
  * 
*/
class ConstantStatement : public Statement {
  private:
    /// single constant variable
      std::shared_ptr<ConstantVar> constant;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ConstantStatement(ConstantVar* constant);
      explicit ConstantStatement(const std::shared_ptr<ConstantVar>& constant);
    ConstantStatement(const ConstantStatement& obj);


  virtual ~ConstantStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ConstantStatement
   * \return true as object is of type ast::ConstantStatement
   */
  bool is_constant_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ConstantStatement* clone() const override {
    return new ConstantStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::CONSTANT_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::CONSTANT_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ConstantStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ConstantStatement";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ConstantStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ConstantStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ConstantStatement.constant
                    */
                   const std::shared_ptr<ConstantVar>& get_constant() const noexcept  {
                       return constant;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ConstantStatement.constant (rvalue reference)
                        */
                       void set_constant(std::shared_ptr<ConstantVar>&& constant);

                       /**
                        * \brief Setter for member variable \ref ConstantStatement.constant
                        */
                       void set_constant(const std::shared_ptr<ConstantVar>& constant);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_CONSTANT_STATEMENT_HPP
#ifndef NMODL_AST_TABLE_STATEMENT_HPP
#define NMODL_AST_TABLE_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents TABLE statement in NMODL
 *
 * 
*/
class TableStatement : public Statement {
  private:
    /// Variables in the table
      NameVector table_vars;
    /// dependent variables
      NameVector depend_vars;
    /// from value
      std::shared_ptr<Expression> from;
    /// to values
      std::shared_ptr<Expression> to;
    /// an increment factor
      std::shared_ptr<Integer> with;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit TableStatement(NameVector table_vars, NameVector depend_vars, Expression* from, Expression* to, Integer* with);
      explicit TableStatement(const NameVector& table_vars, const NameVector& depend_vars, const std::shared_ptr<Expression>& from, const std::shared_ptr<Expression>& to, const std::shared_ptr<Integer>& with);
    TableStatement(const TableStatement& obj);


  virtual ~TableStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::TableStatement
   * \return true as object is of type ast::TableStatement
   */
  bool is_table_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   TableStatement* clone() const override {
    return new TableStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::TABLE_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::TABLE_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "TableStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "TableStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "TABLE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "TABLE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<TableStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const TableStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref TableStatement.table_vars
                    */
                   const NameVector& get_table_vars() const noexcept  {
                       return table_vars;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref TableStatement.depend_vars
                    */
                   const NameVector& get_depend_vars() const noexcept  {
                       return depend_vars;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref TableStatement.from
                    */
                   const std::shared_ptr<Expression>& get_from() const noexcept  {
                       return from;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref TableStatement.to
                    */
                   const std::shared_ptr<Expression>& get_to() const noexcept  {
                       return to;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref TableStatement.with
                    */
                   const std::shared_ptr<Integer>& get_with() const noexcept  {
                       return with;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref TableStatement.table_vars (rvalue reference)
                        */
                       void set_table_vars(NameVector&& table_vars);

                       /**
                        * \brief Setter for member variable \ref TableStatement.table_vars
                        */
                       void set_table_vars(const NameVector& table_vars);
                    
    
                       /**
                        * \brief Setter for member variable \ref TableStatement.depend_vars (rvalue reference)
                        */
                       void set_depend_vars(NameVector&& depend_vars);

                       /**
                        * \brief Setter for member variable \ref TableStatement.depend_vars
                        */
                       void set_depend_vars(const NameVector& depend_vars);
                    
    
                       /**
                        * \brief Setter for member variable \ref TableStatement.from (rvalue reference)
                        */
                       void set_from(std::shared_ptr<Expression>&& from);

                       /**
                        * \brief Setter for member variable \ref TableStatement.from
                        */
                       void set_from(const std::shared_ptr<Expression>& from);
                    
    
                       /**
                        * \brief Setter for member variable \ref TableStatement.to (rvalue reference)
                        */
                       void set_to(std::shared_ptr<Expression>&& to);

                       /**
                        * \brief Setter for member variable \ref TableStatement.to
                        */
                       void set_to(const std::shared_ptr<Expression>& to);
                    
    
                       /**
                        * \brief Setter for member variable \ref TableStatement.with (rvalue reference)
                        */
                       void set_with(std::shared_ptr<Integer>&& with);

                       /**
                        * \brief Setter for member variable \ref TableStatement.with
                        */
                       void set_with(const std::shared_ptr<Integer>& with);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_TABLE_STATEMENT_HPP
#ifndef NMODL_AST_SUFFIX_HPP
#define NMODL_AST_SUFFIX_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents SUFFIX statement in NMODL
 *
 * 
*/
class Suffix : public Statement {
  private:
    /// type of channel
      std::shared_ptr<Name> type;
    /// Name of the channel
      std::shared_ptr<Name> name;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Suffix(Name* type, Name* name);
      explicit Suffix(const std::shared_ptr<Name>& type, const std::shared_ptr<Name>& name);
    Suffix(const Suffix& obj);


  virtual ~Suffix() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Suffix
   * \return true as object is of type ast::Suffix
   */
  bool is_suffix () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Suffix* clone() const override {
    return new Suffix(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SUFFIX
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SUFFIX;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Suffix"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Suffix";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Suffix>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Suffix>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Suffix.type
                    */
                   const std::shared_ptr<Name>& get_type() const noexcept  {
                       return type;
                   }
                

    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Suffix.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Suffix.type (rvalue reference)
                        */
                       void set_type(std::shared_ptr<Name>&& type);

                       /**
                        * \brief Setter for member variable \ref Suffix.type
                        */
                       void set_type(const std::shared_ptr<Name>& type);
                    
    
                       /**
                        * \brief Setter for member variable \ref Suffix.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref Suffix.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SUFFIX_HPP
#ifndef NMODL_AST_USEION_HPP
#define NMODL_AST_USEION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents USEION statement in NMODL
 *
 * 
*/
class Useion : public Statement {
  private:
    /// Name of ion
      std::shared_ptr<Name> name;
    /// Variables being read
      ReadIonVarVector readlist;
    /// Variables being written
      WriteIonVarVector writelist;
    /// (TODO)
      std::shared_ptr<Valence> valence;
    /// Ontology to indicate the chemical ion
      std::shared_ptr<String> ontology_id;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Useion(Name* name, ReadIonVarVector readlist, WriteIonVarVector writelist, Valence* valence, String* ontology_id);
      explicit Useion(const std::shared_ptr<Name>& name, const ReadIonVarVector& readlist, const WriteIonVarVector& writelist, const std::shared_ptr<Valence>& valence, const std::shared_ptr<String>& ontology_id);
    Useion(const Useion& obj);


  virtual ~Useion() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Useion
   * \return true as object is of type ast::Useion
   */
  bool is_useion () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Useion* clone() const override {
    return new Useion(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::USEION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::USEION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Useion"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Useion";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "USEION "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "USEION ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Useion>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Useion>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    
/**
 * \brief Return name of the node
 *
 * Some ast nodes have a member marked designated as node name. For example,
 * in case of this ast::Name has name designated as a
 * node name.
 *
 * @return name of the node as std::string
 *
 * \sa Ast::get_node_type_name
 */
std::string get_node_name() const override;

    
                   /**
                    * \brief Getter for member variable \ref Useion.name
                    */
                   const std::shared_ptr<Name>& get_name() const noexcept  {
                       return name;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Useion.readlist
                    */
                   const ReadIonVarVector& get_readlist() const noexcept  {
                       return readlist;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Useion.writelist
                    */
                   const WriteIonVarVector& get_writelist() const noexcept  {
                       return writelist;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Useion.valence
                    */
                   const std::shared_ptr<Valence>& get_valence() const noexcept  {
                       return valence;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref Useion.ontology_id
                    */
                   const std::shared_ptr<String>& get_ontology_id() const noexcept  {
                       return ontology_id;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Useion.name (rvalue reference)
                        */
                       void set_name(std::shared_ptr<Name>&& name);

                       /**
                        * \brief Setter for member variable \ref Useion.name
                        */
                       void set_name(const std::shared_ptr<Name>& name);
                    
    
                       /**
                        * \brief Setter for member variable \ref Useion.readlist (rvalue reference)
                        */
                       void set_readlist(ReadIonVarVector&& readlist);

                       /**
                        * \brief Setter for member variable \ref Useion.readlist
                        */
                       void set_readlist(const ReadIonVarVector& readlist);
                    
    
                       /**
                        * \brief Setter for member variable \ref Useion.writelist (rvalue reference)
                        */
                       void set_writelist(WriteIonVarVector&& writelist);

                       /**
                        * \brief Setter for member variable \ref Useion.writelist
                        */
                       void set_writelist(const WriteIonVarVector& writelist);
                    
    
                       /**
                        * \brief Setter for member variable \ref Useion.valence (rvalue reference)
                        */
                       void set_valence(std::shared_ptr<Valence>&& valence);

                       /**
                        * \brief Setter for member variable \ref Useion.valence
                        */
                       void set_valence(const std::shared_ptr<Valence>& valence);
                    
    
                       /**
                        * \brief Setter for member variable \ref Useion.ontology_id (rvalue reference)
                        */
                       void set_ontology_id(std::shared_ptr<String>&& ontology_id);

                       /**
                        * \brief Setter for member variable \ref Useion.ontology_id
                        */
                       void set_ontology_id(const std::shared_ptr<String>& ontology_id);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_USEION_HPP
#ifndef NMODL_AST_NONSPECIFIC_HPP
#define NMODL_AST_NONSPECIFIC_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents NONSPECIFIC_CURRENT variables statement in NMODL
 *
 * 
*/
class Nonspecific : public Statement {
  private:
    /// Vector of non specific variables
      NonspecificCurVarVector currents;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Nonspecific(NonspecificCurVarVector currents);
    Nonspecific(const Nonspecific& obj);


  virtual ~Nonspecific() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Nonspecific
   * \return true as object is of type ast::Nonspecific
   */
  bool is_nonspecific () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Nonspecific* clone() const override {
    return new Nonspecific(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NONSPECIFIC
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NONSPECIFIC;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Nonspecific"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Nonspecific";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "NONSPECIFIC_CURRENT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "NONSPECIFIC_CURRENT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Nonspecific>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Nonspecific>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Nonspecific.currents
                    */
                   const NonspecificCurVarVector& get_currents() const noexcept  {
                       return currents;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Nonspecific.currents (rvalue reference)
                        */
                       void set_currents(NonspecificCurVarVector&& currents);

                       /**
                        * \brief Setter for member variable \ref Nonspecific.currents
                        */
                       void set_currents(const NonspecificCurVarVector& currents);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NONSPECIFIC_HPP
#ifndef NMODL_AST_ELECTRODE_CURRENT_HPP
#define NMODL_AST_ELECTRODE_CURRENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents ELECTRODE_CURRENT variables statement in NMODL
 *
 * 
*/
class ElectrodeCurrent : public Statement {
  private:
    /// Vector of electrode current variables
      ElectrodeCurVarVector currents;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ElectrodeCurrent(ElectrodeCurVarVector currents);
    ElectrodeCurrent(const ElectrodeCurrent& obj);


  virtual ~ElectrodeCurrent() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ElectrodeCurrent
   * \return true as object is of type ast::ElectrodeCurrent
   */
  bool is_electrode_current () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ElectrodeCurrent* clone() const override {
    return new ElectrodeCurrent(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ELECTRODE_CURRENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ELECTRODE_CURRENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ElectrodeCurrent"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ElectrodeCurrent";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "ELECTRODE_CURRENT "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "ELECTRODE_CURRENT ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ElectrodeCurrent>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ElectrodeCurrent>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ElectrodeCurrent.currents
                    */
                   const ElectrodeCurVarVector& get_currents() const noexcept  {
                       return currents;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ElectrodeCurrent.currents (rvalue reference)
                        */
                       void set_currents(ElectrodeCurVarVector&& currents);

                       /**
                        * \brief Setter for member variable \ref ElectrodeCurrent.currents
                        */
                       void set_currents(const ElectrodeCurVarVector& currents);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ELECTRODE_CURRENT_HPP
#ifndef NMODL_AST_SECTION_HPP
#define NMODL_AST_SECTION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents SECTION variables statement in NMODL
 *
 * 
*/
class Section : public Statement {
  private:
    /// Vector of section variables
      SectionVarVector sections;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Section(SectionVarVector sections);
    Section(const Section& obj);


  virtual ~Section() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Section
   * \return true as object is of type ast::Section
   */
  bool is_section () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Section* clone() const override {
    return new Section(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SECTION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SECTION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Section"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Section";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "SECTION "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "SECTION ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Section>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Section>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Section.sections
                    */
                   const SectionVarVector& get_sections() const noexcept  {
                       return sections;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Section.sections (rvalue reference)
                        */
                       void set_sections(SectionVarVector&& sections);

                       /**
                        * \brief Setter for member variable \ref Section.sections
                        */
                       void set_sections(const SectionVarVector& sections);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SECTION_HPP
#ifndef NMODL_AST_RANGE_HPP
#define NMODL_AST_RANGE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents RANGE variables statement in NMODL
 *
 * 
*/
class Range : public Statement {
  private:
    /// Vector of range variables
      RangeVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Range(RangeVarVector variables);
    Range(const Range& obj);


  virtual ~Range() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Range
   * \return true as object is of type ast::Range
   */
  bool is_range () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Range* clone() const override {
    return new Range(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::RANGE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::RANGE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Range"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Range";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "RANGE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "RANGE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Range>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Range>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Range.variables
                    */
                   const RangeVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Range.variables (rvalue reference)
                        */
                       void set_variables(RangeVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref Range.variables
                        */
                       void set_variables(const RangeVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_RANGE_HPP
#ifndef NMODL_AST_GLOBAL_HPP
#define NMODL_AST_GLOBAL_HPP
#define NMODL_AST_GLOBAL_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents GLOBAL statement in NMODL
 *
 * 
*/
class Global : public Statement {
  private:
    /// Vector of global variables
      GlobalVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Global(GlobalVarVector variables);
    Global(const Global& obj);


  virtual ~Global() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Global
   * \return true as object is of type ast::Global
   */
  bool is_global () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Global* clone() const override {
    return new Global(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::GLOBAL
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::GLOBAL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Global"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Global";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "GLOBAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "GLOBAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Global>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Global>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    
/**
 * \brief Add member to variables by raw pointer
 */
void emplace_back_global_var(GlobalVar *n);

/**
 * \brief Add member to variables by shared_ptr
 */
void emplace_back_global_var(std::shared_ptr<GlobalVar> n);

/**
 * \brief Erase member to variables
 */
GlobalVarVector::const_iterator erase_global_var(GlobalVarVector::const_iterator first);

/**
 * \brief Erase members to variables
 */
GlobalVarVector::const_iterator erase_global_var(GlobalVarVector::const_iterator first, GlobalVarVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to variables
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_global_var(std::unordered_set<GlobalVar*>& to_be_erased);

/**
 * \brief Insert member to variables
 */
GlobalVarVector::const_iterator insert_global_var(GlobalVarVector::const_iterator position, const std::shared_ptr<GlobalVar>& n);

/**
 * \brief Insert members to variables
 */
template <class NodeType, class InputIterator>
void insert_global_var(GlobalVarVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to variables
 */
void reset_global_var(GlobalVarVector::const_iterator position, GlobalVar* n);

/**
 * \brief Reset member to variables
 */
void reset_global_var(GlobalVarVector::const_iterator position, std::shared_ptr<GlobalVar> n);


    

    
                   /**
                    * \brief Getter for member variable \ref Global.variables
                    */
                   const GlobalVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Global.variables (rvalue reference)
                        */
                       void set_variables(GlobalVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref Global.variables
                        */
                       void set_variables(const GlobalVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_GLOBAL_HPP
#ifndef NMODL_AST_POINTER_HPP
#define NMODL_AST_POINTER_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents POINTER statement in NMODL
 *
 * 
*/
class Pointer : public Statement {
  private:
    /// Vector of pointer variables
      PointerVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Pointer(PointerVarVector variables);
    Pointer(const Pointer& obj);


  virtual ~Pointer() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Pointer
   * \return true as object is of type ast::Pointer
   */
  bool is_pointer () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Pointer* clone() const override {
    return new Pointer(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::POINTER
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::POINTER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Pointer"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Pointer";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "POINTER "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "POINTER ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Pointer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Pointer>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Pointer.variables
                    */
                   const PointerVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Pointer.variables (rvalue reference)
                        */
                       void set_variables(PointerVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref Pointer.variables
                        */
                       void set_variables(const PointerVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_POINTER_HPP
#ifndef NMODL_AST_BBCORE_POINTER_HPP
#define NMODL_AST_BBCORE_POINTER_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents BBCOREPOINTER statement in NMODL
 *
 * Here is an example of BBCOREPOINTER statement:
  * 
  * \code{.mod}
  *       NEURON {
  *           THREADSAFE
  *           POINT_PROCESS ProbAMPANMDA_EMS
  *           BBCOREPOINTER rng, data
  * \endcode
  * 
*/
class BbcorePointer : public Statement {
  private:
    /// Vector of bbcore pointer variables
      BbcorePointerVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BbcorePointer(BbcorePointerVarVector variables);
    BbcorePointer(const BbcorePointer& obj);


  virtual ~BbcorePointer() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointer
   * \return true as object is of type ast::BbcorePointer
   */
  bool is_bbcore_pointer () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BbcorePointer* clone() const override {
    return new BbcorePointer(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BBCORE_POINTER
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BBCORE_POINTER;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BbcorePointer"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BbcorePointer";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "BBCOREPOINTER "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "BBCOREPOINTER ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BbcorePointer>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BbcorePointer>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BbcorePointer.variables
                    */
                   const BbcorePointerVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BbcorePointer.variables (rvalue reference)
                        */
                       void set_variables(BbcorePointerVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref BbcorePointer.variables
                        */
                       void set_variables(const BbcorePointerVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BBCORE_POINTER_HPP
#ifndef NMODL_AST_EXTERNAL_HPP
#define NMODL_AST_EXTERNAL_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents EXTERNAL statement in NMODL
 *
 * 
*/
class External : public Statement {
  private:
    /// Vector of external variables
      ExternVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit External(ExternVarVector variables);
    External(const External& obj);


  virtual ~External() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::External
   * \return true as object is of type ast::External
   */
  bool is_external () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   External* clone() const override {
    return new External(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EXTERNAL
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EXTERNAL;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "External"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "External";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "EXTERNAL "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "EXTERNAL ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<External>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const External>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref External.variables
                    */
                   const ExternVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref External.variables (rvalue reference)
                        */
                       void set_variables(ExternVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref External.variables
                        */
                       void set_variables(const ExternVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EXTERNAL_HPP
#ifndef NMODL_AST_THREAD_SAFE_HPP
#define NMODL_AST_THREAD_SAFE_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents THREADSAFE statement in NMODL
 *
 * 
*/
class ThreadSafe : public Statement {
  private:
    /// Vector of thread safe variables
      ThreadsafeVarVector variables;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit ThreadSafe(ThreadsafeVarVector variables);
    ThreadSafe(const ThreadSafe& obj);


  virtual ~ThreadSafe() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::ThreadSafe
   * \return true as object is of type ast::ThreadSafe
   */
  bool is_thread_safe () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   ThreadSafe* clone() const override {
    return new ThreadSafe(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::THREAD_SAFE
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::THREAD_SAFE;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "ThreadSafe"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "ThreadSafe";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "THREADSAFE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "THREADSAFE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<ThreadSafe>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const ThreadSafe>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref ThreadSafe.variables
                    */
                   const ThreadsafeVarVector& get_variables() const noexcept  {
                       return variables;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref ThreadSafe.variables (rvalue reference)
                        */
                       void set_variables(ThreadsafeVarVector&& variables);

                       /**
                        * \brief Setter for member variable \ref ThreadSafe.variables
                        */
                       void set_variables(const ThreadsafeVarVector& variables);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_THREAD_SAFE_HPP
#ifndef NMODL_AST_VERBATIM_HPP
#define NMODL_AST_VERBATIM_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a C code block
 *
 * 
*/
class Verbatim : public Statement {
  private:
    /// C code as a string
      std::shared_ptr<String> statement;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Verbatim(String* statement);
      explicit Verbatim(const std::shared_ptr<String>& statement);
    Verbatim(const Verbatim& obj);


  virtual ~Verbatim() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Verbatim
   * \return true as object is of type ast::Verbatim
   */
  bool is_verbatim () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Verbatim* clone() const override {
    return new Verbatim(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::VERBATIM
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::VERBATIM;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Verbatim"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Verbatim";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "VERBATIM"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "VERBATIM";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Verbatim>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Verbatim>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref Verbatim.statement
                    */
                   const std::shared_ptr<String>& get_statement() const noexcept  {
                       return statement;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref Verbatim.statement (rvalue reference)
                        */
                       void set_statement(std::shared_ptr<String>&& statement);

                       /**
                        * \brief Setter for member variable \ref Verbatim.statement
                        */
                       void set_statement(const std::shared_ptr<String>& statement);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_VERBATIM_HPP
#ifndef NMODL_AST_LINE_COMMENT_HPP
#define NMODL_AST_LINE_COMMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a one line comment in NMODL
 *
 * 
*/
class LineComment : public Statement {
  private:
    /// comment text
      std::shared_ptr<String> statement;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit LineComment(String* statement);
      explicit LineComment(const std::shared_ptr<String>& statement);
    LineComment(const LineComment& obj);


  virtual ~LineComment() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::LineComment
   * \return true as object is of type ast::LineComment
   */
  bool is_line_comment () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   LineComment* clone() const override {
    return new LineComment(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::LINE_COMMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::LINE_COMMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "LineComment"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "LineComment";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<LineComment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const LineComment>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref LineComment.statement
                    */
                   const std::shared_ptr<String>& get_statement() const noexcept  {
                       return statement;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref LineComment.statement (rvalue reference)
                        */
                       void set_statement(std::shared_ptr<String>&& statement);

                       /**
                        * \brief Setter for member variable \ref LineComment.statement
                        */
                       void set_statement(const std::shared_ptr<String>& statement);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_LINE_COMMENT_HPP
#ifndef NMODL_AST_BLOCK_COMMENT_HPP
#define NMODL_AST_BLOCK_COMMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents a multi-line comment in NMODL
 *
 * 
*/
class BlockComment : public Statement {
  private:
    /// comment text
      std::shared_ptr<String> statement;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit BlockComment(String* statement);
      explicit BlockComment(const std::shared_ptr<String>& statement);
    BlockComment(const BlockComment& obj);


  virtual ~BlockComment() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::BlockComment
   * \return true as object is of type ast::BlockComment
   */
  bool is_block_comment () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   BlockComment* clone() const override {
    return new BlockComment(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::BLOCK_COMMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::BLOCK_COMMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "BlockComment"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "BlockComment";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "COMMENT"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "COMMENT";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<BlockComment>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const BlockComment>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref BlockComment.statement
                    */
                   const std::shared_ptr<String>& get_statement() const noexcept  {
                       return statement;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref BlockComment.statement (rvalue reference)
                        */
                       void set_statement(std::shared_ptr<String>&& statement);

                       /**
                        * \brief Setter for member variable \ref BlockComment.statement
                        */
                       void set_statement(const std::shared_ptr<String>& statement);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_BLOCK_COMMENT_HPP
#ifndef NMODL_AST_ONTOLOGY_STATEMENT_HPP
#define NMODL_AST_ONTOLOGY_STATEMENT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents CURIE information in NMODL
 *
 * 
*/
class OntologyStatement : public Statement {
  private:
    /// Ontology name
      std::shared_ptr<String> ontology_id;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit OntologyStatement(String* ontology_id);
      explicit OntologyStatement(const std::shared_ptr<String>& ontology_id);
    OntologyStatement(const OntologyStatement& obj);


  virtual ~OntologyStatement() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::OntologyStatement
   * \return true as object is of type ast::OntologyStatement
   */
  bool is_ontology_statement () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   OntologyStatement* clone() const override {
    return new OntologyStatement(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::ONTOLOGY_STATEMENT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::ONTOLOGY_STATEMENT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "OntologyStatement"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "OntologyStatement";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "REPRESENTS "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "REPRESENTS ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<OntologyStatement>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const OntologyStatement>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref OntologyStatement.ontology_id
                    */
                   const std::shared_ptr<String>& get_ontology_id() const noexcept  {
                       return ontology_id;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref OntologyStatement.ontology_id (rvalue reference)
                        */
                       void set_ontology_id(std::shared_ptr<String>&& ontology_id);

                       /**
                        * \brief Setter for member variable \ref OntologyStatement.ontology_id
                        */
                       void set_ontology_id(const std::shared_ptr<String>& ontology_id);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_ONTOLOGY_STATEMENT_HPP
#ifndef NMODL_AST_PROGRAM_HPP
#define NMODL_AST_PROGRAM_HPP
#define NMODL_AST_PROGRAM_HPP_INLINE_DEFINITION_REQUIRED


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents top level AST node for whole NMODL input
 *
 * 
*/
class Program : public Ast {
  private:
    /// Vector of top level blocks in the mod file
      NodeVector blocks;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;
    /// global symbol table for model
      symtab::ModelSymbolTable model_symtab;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit Program(NodeVector blocks);
    Program(const Program& obj);

    Program() = default;

  virtual ~Program() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::Program
   * \return true as object is of type ast::Program
   */
  bool is_program () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   Program* clone() const override {
    return new Program(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::PROGRAM
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::PROGRAM;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "Program"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "Program";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<Program>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const Program>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }


    /**
     * \brief Return global symbol table for the mod file
     */
    symtab::ModelSymbolTable* get_model_symbol_table() {
      return &model_symtab;
    }

    
/**
 * \brief Add member to blocks by raw pointer
 */
void emplace_back_node(Node *n);

/**
 * \brief Add member to blocks by shared_ptr
 */
void emplace_back_node(std::shared_ptr<Node> n);

/**
 * \brief Erase member to blocks
 */
NodeVector::const_iterator erase_node(NodeVector::const_iterator first);

/**
 * \brief Erase members to blocks
 */
NodeVector::const_iterator erase_node(NodeVector::const_iterator first, NodeVector::const_iterator last);

/**
 * \brief Erase non-consecutive members to blocks
 *
 * loosely following the cpp reference of remove_if
 */
size_t erase_node(std::unordered_set<Node*>& to_be_erased);

/**
 * \brief Insert member to blocks
 */
NodeVector::const_iterator insert_node(NodeVector::const_iterator position, const std::shared_ptr<Node>& n);

/**
 * \brief Insert members to blocks
 */
template <class NodeType, class InputIterator>
void insert_node(NodeVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last);

/**
 * \brief Reset member to blocks
 */
void reset_node(NodeVector::const_iterator position, Node* n);

/**
 * \brief Reset member to blocks
 */
void reset_node(NodeVector::const_iterator position, std::shared_ptr<Node> n);


    

    
                   /**
                    * \brief Getter for member variable \ref Program.blocks
                    */
                   const NodeVector& get_blocks() const noexcept  {
                       return blocks;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref Program.blocks (rvalue reference)
                        */
                       void set_blocks(NodeVector&& blocks);

                       /**
                        * \brief Setter for member variable \ref Program.blocks
                        */
                       void set_blocks(const NodeVector& blocks);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_PROGRAM_HPP
#ifndef NMODL_AST_NRN_STATE_BLOCK_HPP
#define NMODL_AST_NRN_STATE_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represents the coreneuron nrn_state callback function
 *
 * 
*/
class NrnStateBlock : public Block {
  private:
    /// solve blocks to be called or generated
      StatementVector solve_statements;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit NrnStateBlock(StatementVector solve_statements);
    NrnStateBlock(const NrnStateBlock& obj);


  virtual ~NrnStateBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::NrnStateBlock
   * \return true as object is of type ast::NrnStateBlock
   */
  bool is_nrn_state_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   NrnStateBlock* clone() const override {
    return new NrnStateBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::NRN_STATE_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::NRN_STATE_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "NrnStateBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "NrnStateBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "NRN_STATE "
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "NRN_STATE ";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<NrnStateBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const NrnStateBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref NrnStateBlock.solve_statements
                    */
                   const StatementVector& get_solve_statements() const noexcept  {
                       return solve_statements;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref NrnStateBlock.solve_statements (rvalue reference)
                        */
                       void set_solve_statements(StatementVector&& solve_statements);

                       /**
                        * \brief Setter for member variable \ref NrnStateBlock.solve_statements
                        */
                       void set_solve_statements(const StatementVector& solve_statements);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_NRN_STATE_BLOCK_HPP
#ifndef NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP
#define NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent newton solver solution block based on Eigen
 *
 * 
*/
class EigenNewtonSolverBlock : public Block {
  private:
    /// number of state vars used in solve
      std::shared_ptr<Integer> n_state_vars;
    /// Statements to be declared in the functor
      std::shared_ptr<StatementBlock> variable_block;
    /// Statement block to be executed before calling newton solver
      std::shared_ptr<StatementBlock> initialize_block;
    /// update X from states
      std::shared_ptr<StatementBlock> setup_x_block;
    /// odes as functor for eigen
      std::shared_ptr<StatementBlock> functor_block;
    /// update back states from X
      std::shared_ptr<StatementBlock> update_states_block;
    /// Statement block to be executed after calling newton solver
      std::shared_ptr<StatementBlock> finalize_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit EigenNewtonSolverBlock(Integer* n_state_vars, StatementBlock* variable_block, StatementBlock* initialize_block, StatementBlock* setup_x_block, StatementBlock* functor_block, StatementBlock* update_states_block, StatementBlock* finalize_block);
      explicit EigenNewtonSolverBlock(const std::shared_ptr<Integer>& n_state_vars, const std::shared_ptr<StatementBlock>& variable_block, const std::shared_ptr<StatementBlock>& initialize_block, const std::shared_ptr<StatementBlock>& setup_x_block, const std::shared_ptr<StatementBlock>& functor_block, const std::shared_ptr<StatementBlock>& update_states_block, const std::shared_ptr<StatementBlock>& finalize_block);
    EigenNewtonSolverBlock(const EigenNewtonSolverBlock& obj);


  virtual ~EigenNewtonSolverBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::EigenNewtonSolverBlock
   * \return true as object is of type ast::EigenNewtonSolverBlock
   */
  bool is_eigen_newton_solver_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   EigenNewtonSolverBlock* clone() const override {
    return new EigenNewtonSolverBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EIGEN_NEWTON_SOLVER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "EigenNewtonSolverBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "EigenNewtonSolverBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "EIGEN_NEWTON_SOLVE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "EIGEN_NEWTON_SOLVE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<EigenNewtonSolverBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const EigenNewtonSolverBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.n_state_vars
                    */
                   const std::shared_ptr<Integer>& get_n_state_vars() const noexcept  {
                       return n_state_vars;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.variable_block
                    */
                   const std::shared_ptr<StatementBlock>& get_variable_block() const noexcept  {
                       return variable_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.initialize_block
                    */
                   const std::shared_ptr<StatementBlock>& get_initialize_block() const noexcept  {
                       return initialize_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.setup_x_block
                    */
                   const std::shared_ptr<StatementBlock>& get_setup_x_block() const noexcept  {
                       return setup_x_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.functor_block
                    */
                   const std::shared_ptr<StatementBlock>& get_functor_block() const noexcept  {
                       return functor_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.update_states_block
                    */
                   const std::shared_ptr<StatementBlock>& get_update_states_block() const noexcept  {
                       return update_states_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenNewtonSolverBlock.finalize_block
                    */
                   const std::shared_ptr<StatementBlock>& get_finalize_block() const noexcept  {
                       return finalize_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars (rvalue reference)
                        */
                       void set_n_state_vars(std::shared_ptr<Integer>&& n_state_vars);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.n_state_vars
                        */
                       void set_n_state_vars(const std::shared_ptr<Integer>& n_state_vars);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.variable_block (rvalue reference)
                        */
                       void set_variable_block(std::shared_ptr<StatementBlock>&& variable_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.variable_block
                        */
                       void set_variable_block(const std::shared_ptr<StatementBlock>& variable_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.initialize_block (rvalue reference)
                        */
                       void set_initialize_block(std::shared_ptr<StatementBlock>&& initialize_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.initialize_block
                        */
                       void set_initialize_block(const std::shared_ptr<StatementBlock>& initialize_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block (rvalue reference)
                        */
                       void set_setup_x_block(std::shared_ptr<StatementBlock>&& setup_x_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.setup_x_block
                        */
                       void set_setup_x_block(const std::shared_ptr<StatementBlock>& setup_x_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block (rvalue reference)
                        */
                       void set_functor_block(std::shared_ptr<StatementBlock>&& functor_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.functor_block
                        */
                       void set_functor_block(const std::shared_ptr<StatementBlock>& functor_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.update_states_block (rvalue reference)
                        */
                       void set_update_states_block(std::shared_ptr<StatementBlock>&& update_states_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.update_states_block
                        */
                       void set_update_states_block(const std::shared_ptr<StatementBlock>& update_states_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.finalize_block (rvalue reference)
                        */
                       void set_finalize_block(std::shared_ptr<StatementBlock>&& finalize_block);

                       /**
                        * \brief Setter for member variable \ref EigenNewtonSolverBlock.finalize_block
                        */
                       void set_finalize_block(const std::shared_ptr<StatementBlock>& finalize_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EIGEN_NEWTON_SOLVER_BLOCK_HPP
#ifndef NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP
#define NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent linear solver solution block based on Eigen
 *
 * 
*/
class EigenLinearSolverBlock : public Block {
  private:
    /// number of state vars used in solve
      std::shared_ptr<Integer> n_state_vars;
    /// Statements to be declared in the functor
      std::shared_ptr<StatementBlock> variable_block;
    /// Statement block to be executed before calling linear solver
      std::shared_ptr<StatementBlock> initialize_block;
    /// update X from states
      std::shared_ptr<StatementBlock> setup_x_block;
    /// update back states from X
      std::shared_ptr<StatementBlock> update_states_block;
    /// Statement block to be executed after calling linear solver
      std::shared_ptr<StatementBlock> finalize_block;
    /// token with location information
      std::shared_ptr<ModToken> token;
    /// symbol table for a block
      symtab::SymbolTable* symtab = nullptr;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit EigenLinearSolverBlock(Integer* n_state_vars, StatementBlock* variable_block, StatementBlock* initialize_block, StatementBlock* setup_x_block, StatementBlock* update_states_block, StatementBlock* finalize_block);
      explicit EigenLinearSolverBlock(const std::shared_ptr<Integer>& n_state_vars, const std::shared_ptr<StatementBlock>& variable_block, const std::shared_ptr<StatementBlock>& initialize_block, const std::shared_ptr<StatementBlock>& setup_x_block, const std::shared_ptr<StatementBlock>& update_states_block, const std::shared_ptr<StatementBlock>& finalize_block);
    EigenLinearSolverBlock(const EigenLinearSolverBlock& obj);


  virtual ~EigenLinearSolverBlock() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::EigenLinearSolverBlock
   * \return true as object is of type ast::EigenLinearSolverBlock
   */
  bool is_eigen_linear_solver_block () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   EigenLinearSolverBlock* clone() const override {
    return new EigenLinearSolverBlock(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::EIGEN_LINEAR_SOLVER_BLOCK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::EIGEN_LINEAR_SOLVER_BLOCK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "EigenLinearSolverBlock"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "EigenLinearSolverBlock";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "EIGEN_LINEAR_SOLVE"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "EIGEN_LINEAR_SOLVE";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<EigenLinearSolverBlock>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const EigenLinearSolverBlock>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }

    /**
     * \brief Return associated symbol table for the current ast node
     *
     * Only certain ast nodes (e.g. inherited from ast::Block) have associated
     * symbol table. These nodes have nmodl::symtab::SymbolTable as member
     * and it can be accessed using this method.
     *
     * \return pointer to the symbol table
     *
     * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
     */
    symtab::SymbolTable* get_symbol_table() const override {
      return symtab;
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.n_state_vars
                    */
                   const std::shared_ptr<Integer>& get_n_state_vars() const noexcept  {
                       return n_state_vars;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.variable_block
                    */
                   const std::shared_ptr<StatementBlock>& get_variable_block() const noexcept  {
                       return variable_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.initialize_block
                    */
                   const std::shared_ptr<StatementBlock>& get_initialize_block() const noexcept  {
                       return initialize_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.setup_x_block
                    */
                   const std::shared_ptr<StatementBlock>& get_setup_x_block() const noexcept  {
                       return setup_x_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.update_states_block
                    */
                   const std::shared_ptr<StatementBlock>& get_update_states_block() const noexcept  {
                       return update_states_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref EigenLinearSolverBlock.finalize_block
                    */
                   const std::shared_ptr<StatementBlock>& get_finalize_block() const noexcept  {
                       return finalize_block;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }

    /**
     * \brief Set symbol table for the current ast node
     *
     * Top level, block scoped nodes store symbol table in the ast node.
     * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
     * for every node in the ast.
     *
     * \sa nmodl::visitor::SymtabVisitor
     */
    void set_symbol_table(symtab::SymbolTable* newsymtab) override {
      symtab = newsymtab;
    }


    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.n_state_vars (rvalue reference)
                        */
                       void set_n_state_vars(std::shared_ptr<Integer>&& n_state_vars);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.n_state_vars
                        */
                       void set_n_state_vars(const std::shared_ptr<Integer>& n_state_vars);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.variable_block (rvalue reference)
                        */
                       void set_variable_block(std::shared_ptr<StatementBlock>&& variable_block);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.variable_block
                        */
                       void set_variable_block(const std::shared_ptr<StatementBlock>& variable_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.initialize_block (rvalue reference)
                        */
                       void set_initialize_block(std::shared_ptr<StatementBlock>&& initialize_block);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.initialize_block
                        */
                       void set_initialize_block(const std::shared_ptr<StatementBlock>& initialize_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.setup_x_block (rvalue reference)
                        */
                       void set_setup_x_block(std::shared_ptr<StatementBlock>&& setup_x_block);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.setup_x_block
                        */
                       void set_setup_x_block(const std::shared_ptr<StatementBlock>& setup_x_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.update_states_block (rvalue reference)
                        */
                       void set_update_states_block(std::shared_ptr<StatementBlock>&& update_states_block);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.update_states_block
                        */
                       void set_update_states_block(const std::shared_ptr<StatementBlock>& update_states_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.finalize_block (rvalue reference)
                        */
                       void set_finalize_block(std::shared_ptr<StatementBlock>&& finalize_block);

                       /**
                        * \brief Setter for member variable \ref EigenLinearSolverBlock.finalize_block
                        */
                       void set_finalize_block(const std::shared_ptr<StatementBlock>& finalize_block);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_EIGEN_LINEAR_SOLVER_BLOCK_HPP
#ifndef NMODL_AST_WRAPPED_EXPRESSION_HPP
#define NMODL_AST_WRAPPED_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Wrap any other expression type
 *
 * 
*/
class WrappedExpression : public Expression {
  private:
    /// Expression that is being wrapped
      std::shared_ptr<Expression> expression;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit WrappedExpression(Expression* expression);
      explicit WrappedExpression(const std::shared_ptr<Expression>& expression);
    WrappedExpression(const WrappedExpression& obj);


  virtual ~WrappedExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::WrappedExpression
   * \return true as object is of type ast::WrappedExpression
   */
  bool is_wrapped_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   WrappedExpression* clone() const override {
    return new WrappedExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::WRAPPED_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::WRAPPED_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "WrappedExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "WrappedExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<WrappedExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const WrappedExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref WrappedExpression.expression
                    */
                   const std::shared_ptr<Expression>& get_expression() const noexcept  {
                       return expression;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref WrappedExpression.expression (rvalue reference)
                        */
                       void set_expression(std::shared_ptr<Expression>&& expression);

                       /**
                        * \brief Setter for member variable \ref WrappedExpression.expression
                        */
                       void set_expression(const std::shared_ptr<Expression>& expression);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_WRAPPED_EXPRESSION_HPP
#ifndef NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP
#define NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent a callback to NEURON's derivimplicit solver
 *
 * 
*/
class DerivimplicitCallback : public Expression {
  private:
    /// Block to be solved (typically derivative)
      std::shared_ptr<Block> node_to_solve;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit DerivimplicitCallback(Block* node_to_solve);
      explicit DerivimplicitCallback(const std::shared_ptr<Block>& node_to_solve);
    DerivimplicitCallback(const DerivimplicitCallback& obj);


  virtual ~DerivimplicitCallback() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::DerivimplicitCallback
   * \return true as object is of type ast::DerivimplicitCallback
   */
  bool is_derivimplicit_callback () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   DerivimplicitCallback* clone() const override {
    return new DerivimplicitCallback(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::DERIVIMPLICIT_CALLBACK
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::DERIVIMPLICIT_CALLBACK;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "DerivimplicitCallback"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "DerivimplicitCallback";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<DerivimplicitCallback>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const DerivimplicitCallback>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref DerivimplicitCallback.node_to_solve
                    */
                   const std::shared_ptr<Block>& get_node_to_solve() const noexcept  {
                       return node_to_solve;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref DerivimplicitCallback.node_to_solve (rvalue reference)
                        */
                       void set_node_to_solve(std::shared_ptr<Block>&& node_to_solve);

                       /**
                        * \brief Setter for member variable \ref DerivimplicitCallback.node_to_solve
                        */
                       void set_node_to_solve(const std::shared_ptr<Block>& node_to_solve);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_DERIVIMPLICIT_CALLBACK_HPP
#ifndef NMODL_AST_SOLUTION_EXPRESSION_HPP
#define NMODL_AST_SOLUTION_EXPRESSION_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Represent solution of a block in the AST
 *
 * 
*/
class SolutionExpression : public Expression {
  private:
    /// 
      std::shared_ptr<SolveBlock> solve_block;
    /// Block to be solved (callback node or solution node itself)
      std::shared_ptr<Expression> node_to_solve;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit SolutionExpression(SolveBlock* solve_block, Expression* node_to_solve);
      explicit SolutionExpression(const std::shared_ptr<SolveBlock>& solve_block, const std::shared_ptr<Expression>& node_to_solve);
    SolutionExpression(const SolutionExpression& obj);


  virtual ~SolutionExpression() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::SolutionExpression
   * \return true as object is of type ast::SolutionExpression
   */
  bool is_solution_expression () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   SolutionExpression* clone() const override {
    return new SolutionExpression(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::SOLUTION_EXPRESSION
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::SOLUTION_EXPRESSION;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "SolutionExpression"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "SolutionExpression";
  }


  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<SolutionExpression>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const SolutionExpression>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref SolutionExpression.solve_block
                    */
                   const std::shared_ptr<SolveBlock>& get_solve_block() const noexcept  {
                       return solve_block;
                   }
                

    

    

    
                   /**
                    * \brief Getter for member variable \ref SolutionExpression.node_to_solve
                    */
                   const std::shared_ptr<Expression>& get_node_to_solve() const noexcept  {
                       return node_to_solve;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref SolutionExpression.solve_block (rvalue reference)
                        */
                       void set_solve_block(std::shared_ptr<SolveBlock>&& solve_block);

                       /**
                        * \brief Setter for member variable \ref SolutionExpression.solve_block
                        */
                       void set_solve_block(const std::shared_ptr<SolveBlock>& solve_block);
                    
    
                       /**
                        * \brief Setter for member variable \ref SolutionExpression.node_to_solve (rvalue reference)
                        */
                       void set_node_to_solve(std::shared_ptr<Expression>&& node_to_solve);

                       /**
                        * \brief Setter for member variable \ref SolutionExpression.node_to_solve
                        */
                       void set_node_to_solve(const std::shared_ptr<Expression>& node_to_solve);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_SOLUTION_EXPRESSION_HPP
#ifndef NMODL_AST_UPDATE_DT_HPP
#define NMODL_AST_UPDATE_DT_HPP


namespace nmodl {
namespace ast {

/**
 * @addtogroup ast_class
 * @ingroup ast
 * @{
 */

/**
 * \brief Statement to indicate a change in timestep in a given block
 *
 * 
*/
class UpdateDt : public Statement {
  private:
    /// Value of new timestep
      std::shared_ptr<Double> value;
    /// token with location information
      std::shared_ptr<ModToken> token;

  public:

  /// \name Ctor & dtor
  /// \{

    explicit UpdateDt(Double* value);
      explicit UpdateDt(const std::shared_ptr<Double>& value);
    UpdateDt(const UpdateDt& obj);


  virtual ~UpdateDt() = default;

  /// \}




  

  /**
   * \brief Check if the ast node is an instance of ast::UpdateDt
   * \return true as object is of type ast::UpdateDt
   */
  bool is_update_dt () const noexcept override {
    return true;
  }

  /**
   * \brief Return a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * @return pointer to the clone/copy of the current node
   */
   UpdateDt* clone() const override {
    return new UpdateDt(*this);
  }

  /// \name Getters
  /// \{

  /**
   * \brief Return type (ast::AstNodeType) of ast node
   *
   * Every node in the ast has a type defined in ast::AstNodeType and this
   * function is used to retrieve the same.
   *
   * \return ast node type i.e. ast::AstNodeType::UPDATE_DT
   *
   * \sa Ast::get_node_type_name
   */
   AstNodeType get_node_type() const noexcept override {
    return AstNodeType::UPDATE_DT;
  }

  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * node to text/json form.
   *
   * \return name of the node type as a string i.e. "UpdateDt"
   *
   * \sa Ast::get_node_name
   */
   std::string get_node_type_name() const noexcept override {
    return "UpdateDt";
  }

    /**
     * \brief Return NMODL statement of ast node as std::string
     *
     * Every node is related to a special statement in the NMODL. This
     * statement can be returned as a std::string for printing to
     * text/json form.
     *
     * \return name of the statement as a string i.e. "dt"
     *
     * \sa Ast::get_nmodl_name
     */
     std::string get_nmodl_name() const noexcept override {
      return "dt";
    }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<Ast> get_shared_ptr() override {
    return std::static_pointer_cast<UpdateDt>(shared_from_this());
  }

  /**
   * \brief Get std::shared_ptr from `this` pointer of the current ast node
   */
   std::shared_ptr<const Ast> get_shared_ptr() const override {
    return std::static_pointer_cast<const UpdateDt>(shared_from_this());
  }

    /**
     * \brief Return associated token for the current ast node
     *
     * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
     * can insert new nodes in the ast as a solution of ODEs. In this case, we return
     * nullptr to store in the nmodl::symtab::SymbolTable.
     *
     * \return pointer to token if exist otherwise nullptr
     */
    const ModToken* get_token() const noexcept override {
      return token.get();
    }



    

    

    
                   /**
                    * \brief Getter for member variable \ref UpdateDt.value
                    */
                   const std::shared_ptr<Double>& get_value() const noexcept  {
                       return value;
                   }
                


  /// \}

  /// \name Setters
  /// \{


    /**
     * \brief Set token for the current ast node
     */
    void set_token(const ModToken& tok) { token = std::make_shared<ModToken>(tok); }



    
                       /**
                        * \brief Setter for member variable \ref UpdateDt.value (rvalue reference)
                        */
                       void set_value(std::shared_ptr<Double>&& value);

                       /**
                        * \brief Setter for member variable \ref UpdateDt.value
                        */
                       void set_value(const std::shared_ptr<Double>& value);
                    

  /// \}

  /// \name Visitor
  /// \{

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::Visitor& v) override;

  /**
   * \brief visit children i.e. member variables of current node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided visitor.
   *
   * \param v Concrete constant visitor that will be used to recursively visit children
   *
   * \sa Ast::visit_children for example.
   */
   void visit_children(visitor::ConstVisitor& v) const override;

  /**
   * \brief accept (or visit) the current AST node using provided visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using provided concrete
   * visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \sa Ast::accept for example.
   */
   void accept(visitor::Visitor& v) override;

  /**
   * \copydoc accept(visitor::Visitor&)
   */
   void accept(visitor::ConstVisitor& v) const override;

  /// \}



  private:
    /**
     * \brief Set this object as parent for all the children
     *
     * This should be called in every object (with children) constructor
     * to set parents. Since it is called only in the constructors it
     * should not be virtual to avoid ambiguities (issue #295).
     */
     void set_parent_in_children();
};

/** @} */  // end of ast_class


}  // namespace ast
}  // namespace nmodl
#endif // !NMODL_AST_UPDATE_DT_HPP

namespace nmodl {
namespace ast {
#ifdef NMODL_AST_ASSIGNED_BLOCK_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to definitions
 */
template <class NodeType, class InputIterator>
void AssignedBlock::insert_assigned_definition(AssignedDefinitionVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    definitions.insert(position, first, last);
}

#endif  // !NMODL_AST_ASSIGNED_BLOCK_HPP_INLINE_DEFINITION_REQUIRED

#ifdef NMODL_AST_STATEMENT_BLOCK_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to statements
 */
template <class NodeType, class InputIterator>
void StatementBlock::insert_statement(StatementVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    statements.insert(position, first, last);
}

#endif  // !NMODL_AST_STATEMENT_BLOCK_HPP_INLINE_DEFINITION_REQUIRED

#ifdef NMODL_AST_LOCAL_LIST_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to variables
 */
template <class NodeType, class InputIterator>
void LocalListStatement::insert_local_var(LocalVarVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    variables.insert(position, first, last);
}

#endif  // !NMODL_AST_LOCAL_LIST_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED

#ifdef NMODL_AST_WATCH_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to statements
 */
template <class NodeType, class InputIterator>
void WatchStatement::insert_watch(WatchVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    statements.insert(position, first, last);
}

#endif  // !NMODL_AST_WATCH_STATEMENT_HPP_INLINE_DEFINITION_REQUIRED

#ifdef NMODL_AST_GLOBAL_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to variables
 */
template <class NodeType, class InputIterator>
void Global::insert_global_var(GlobalVarVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    variables.insert(position, first, last);
}

#endif  // !NMODL_AST_GLOBAL_HPP_INLINE_DEFINITION_REQUIRED

#ifdef NMODL_AST_PROGRAM_HPP_INLINE_DEFINITION_REQUIRED
  
/**
 * \brief Insert members to blocks
 */
template <class NodeType, class InputIterator>
void Program::insert_node(NodeVector::const_iterator position, NodeType& to, InputIterator first, InputIterator last) {

    for (auto it = first; it != last; ++it) {
        auto& n = *it;
        //set parents
        n->set_parent(this); 
     }
    blocks.insert(position, first, last);
}

#endif  // !NMODL_AST_PROGRAM_HPP_INLINE_DEFINITION_REQUIRED

}  // namespace ast
}  // namespace nmodl